Forem: eXpLorE wItH mE

🧠 Managed vs Unmanaged Code — Explained for Beginners

eXpLorE wItH mE — Wed, 05 Nov 2025 08:11:24 +0000

If you're learning C# or exploring .NET, you've probably heard the terms managed code and unmanaged code. This post breaks down what they mean, how they differ, and why it matters — using real-world analogies and examples.

🔧 What Is Managed Code?

Managed code is code that runs under the supervision of a runtime environment — in C#, that’s the .NET Runtime (CLR).
✅ Features of Managed Code:

Automatic memory management (garbage collection)
Type safety and security
Exception handling
Cross-platform support

🏢 Real-world analogy: Managed code is like living in a smart apartment — the system handles electricity, plumbing, and security for you.

🧠 What Is a Runtime Environment?

A runtime environment is software that manages the execution of programs written in certain languages.You can install them from their official websites.Once installed, they allow you to run and build applications in that language.

🧱 What Is Unmanaged Code?

Unmanaged code runs directly on the operating system without a runtime managing it. You’re responsible for memory, safety, and cleanup.

❌ Features of Unmanaged Code:

Manual memory management
No built-in safety or garbage collection
Platform-specific

🏕️ Real-world analogy: Unmanaged code is like building your own cabin in the woods — you control everything, but you also maintain everything yourself.

📦 What Is an Assembly?
When you compile managed C# code, it’s packaged into a binary unit called an assembly (.dll or .exe). Assemblies contain:

Compiled code
Metadata
Optional resources

📦 Think of an assembly as a software package that the .NET Runtime knows how to run.

Building Blocks of the .NET Platform — Explained for Beginners

eXpLorE wItH mE — Wed, 05 Nov 2025 05:18:10 +0000

If you're new to .NET, understanding its core building blocks is essential. This guide breaks down the key components — from the runtime engine to the shared libraries — using simple language and real-world analogies.
Let’s break down the main elements that enable .NET applications: the .NET Runtime, CTS, and CLS.

🔧 .NET Runtime
The .NET Runtime is the core engine that runs .NET applicationsIt includes the Common Language Runtime (CLR), which:

Manages memory
Handles exceptions
Provides system services It adapts to different platforms (Windows, Linux, iOS) and architectures (x86, x64, ARM).

🧠 Think of the .NET Runtime as the engine that powers your application — it manages memory, handles errors, and ensures smooth execution across different systems.

📐 Common Type System (CTS)

The Common Type System (CTS) describes all possible data types and programming constructs supported by the runtime.

It specifies how these entities interact and how they are represented in the .NET metadata format.

🧠 Think of CTS as a universal building code — it ensures that all .NET languages follow the same rules so they can work together.

📘 Common Language Specification (CLS)

A given .NET language might not support every feature defined by the CTS.

The Common Language Specification (CLS) defines a subset of common types and programming constructs that all .NET languages can agree on.

✅ If you build .NET types using only CLS-compliant features, they can be used by any .NET language.

❌ If you use features outside CLS (like uint in C#), other languages may not understand your code.

You can tell your C# compiler to check for CLS compliance using:

csharp
[assembly: CLSCompliant(true)]

🧠 Think of CLS as a basic blueprint — every builder (language) understands it, even if some advanced tools are left out.

📚 The Role of the Base Class Library (BCL)
The .NET platform provides a set of Base Class Libraries (BCLs) available to all .NET languages.

These libraries include support for:

Threads
File I/O
Graphics
External hardware interaction
Networking

🧰 Think of the BCL as a toolbox — it gives you everything you need to build real-world applications.

.NET Standard

.NET Standard is a specification that defines a uniform set of APIs every .NET implementation must support.

It solves compatibility issues between .NET Framework and .NET Core/.NET 5+.

🧰 Think of it as a universal checklist that every .NET platform must follow so developers can write code that works everywhere.

It enables:

Portable libraries across platforms
Consistent API availability
Less conditional compilation

🔄 Think of it as a universal adapter that connects different .NET versions.

.NET Standard enables:

A uniform set of APIs across platforms
Portable libraries
Less conditional compilation

🚫 No New Versions of .NET Standard

Microsoft has stopped releasing new versions of .NET Standard.
Instead, they’ve built .NET 5+ as a single platform that includes everything developers need.
But .NET 5+ still supports .NET Standard 2.1 and earlier, so older libraries still work.

By understanding these foundational pieces, you’ll be better equipped to build cross-platform .NET applications and write code that’s compatible across the ecosystem.

Beginner’s Guide to .NET Development

eXpLorE wItH mE — Tue, 04 Nov 2025 11:13:27 +0000

Modern object-oriented programming language developed by Microsoft.
It is simple, powerful & versatile making it great for building a wide range of applications, from desktop software to web service & games.
ASP.NET is a web framework also developed by Microsoft. It supports several programming languages C#,VB.NET & F#. It is for creating server side code.

.NET Runtime - Core component. It includes CLR(Common Language Runtime), which manages memory, handles exceptions and provides other system services.

The CLR is like the engine of a car. Just as an engine runs the car, the CLR runs .NET applications.

.NET Libraries - A vast collection of pre-built code that developers can use to perform common tasks, such as file handling, data access, and network communication.

The Class Library is like a toolbox filled with tools.

using System;
class Program 
{
static void Main()
  {
        // Using the Class Library to print a message to the console
        Console.WriteLine("Hello, World!");
        // Using the Class Library to get the current date and time
        DateTime now = DateTime.Now;
        Console.WriteLine("Current Date and Time: " + now);
  }
}

C# is a programming language that is both object-oriented and component oriented.

It is based on C++ and Java, but it has many additional extensions used to perform component oriented programming approach.

Hello C# World

using System; namespace HelloWorldApplication { class HelloWorld { static void Main(string[] args) { /* my first program in C# */ - comments Console.WriteLine("Hello World"); Console.ReadKey(); } } }

using System : the using keyword is used to include the System namespace in the program. A program generally has multiple using statements. It is like import statement.

using System; is like saying, "I want to use the tools from the 'System' section of the library."
Imagine you're in a large library with thousands of books. Each section of the library is like a namespace, and each book is like a class or a function within that namespace. Now, if you want to read a book from the "Science" section, you don't want to walk to the "Science" section every time you need a book. Instead, you can bring the books you need to your table.

namespace : A namespace is groups of related classes together.

Think of a namespace as a specific section in a library. This section contains a collection of books on a particular topic. "Science Fiction" section in a library is like a namespace.

Class : A class is a blueprint or template in programming that defines the structure and behavior (data and methods) of objects.

Think of a class as a book in a library. This book contains chapters, which are like methods. Each chapter provides specific information or instructions (behavior). While most books have multiple chapters, our HelloWorld class is a simple book with just one chapter called Main, which contains all the information and instructions for one task.

Main : The Main method is like the front door of a house. When you open it, you enter and see everything inside. Similarly, when a C# program runs, it starts with the Main method, which tells the program what to do first.

Class: A blueprint that defines the structure and behavior of objects.
Namespace: A grouping of related classes.
Assembly: A compiled code package that contains multiple namespaces all bundled together into a single file (like a DLL or EXE).
Application: A complete program made up of multiple assemblies.

Key Benefits

Supports for numerous programming languages - C#,F# (primary languages for ASP.NET core)
A common runtime engine shared by all .NET languages

A comprehensive base class library - .NET gives you a huge collection of ready-made tools (called classes and types) that help you build all kinds of apps.
Simplified Deployment Model - .NET apps are easy to install and run — no need to mess with system settings or the Windows registry.
.NET apps don’t rely on the registry. Instead, they: Run from their own folder. Can be copied and moved easily, Don’t interfere with other apps or system settings, Allow multiple versions of .NET and apps to coexist peacefully.

🔄 You can have: One app using .NET 6. Another using .NET 8 → Both work fine on the same machine without registry conflicts.

Factory Design Pattern - Creational Design Pattern

eXpLorE wItH mE — Wed, 20 Nov 2024 03:20:09 +0000

Creational design pattern - ways to create objects.
These design patterns are used when a decision must be made at the time of instantiation of a class (i.e. creating an object of a class).
It provides a great deal of flexibility in what is created , who creates it, and how it is created

Factory Method Design Pattern

Factory design pattern defines an interface for creation objects, but allow sub classes to alter the type of objects that will be created.
The Factory Design Pattern allows you to delegate the responsibility of object creation to a factory class, instead of directly instantiating the class yourself in the client code.

Real-World Example:
Imagine you have are running a factory that produces different vehicles: cars, bikes & trucks. The process of manufacturing each type of vehicle is different. But the person ordering vehicle doesn't know the details how each vehicle is produced-they just need their vehicle.
Instead of exposing the complex logic of vehicle creation to the client, we use a factory method to handle the creation process for us. The client only interacts with a single interface, and the factory decides which specific type of vehicle to create.
Instead of directly creating concrete classes (like Car(),Bike()..) the factory method pattern provides an interface or abstract class with factory method that is implemented by concrete classes.

// Abstract Product (Vehicle)
class Vehicle {
  manufacture() {
    throw new Error("This method should be overridden by concrete products");
  }
}

// Concrete Products
class Car extends Vehicle {
  manufacture() {
    return "Manufacturing a Car.";
  }
}

class Bike extends Vehicle {
  manufacture() {
    return "Manufacturing a Bike.";
  }
}

class Truck extends Vehicle {
  manufacture() {
    return "Manufacturing a Truck.";
  }
}

// Abstract Factory
class VehicleFactory {
  createVehicle() {
    throw new Error("This method should be implemented by concrete factories");
  }
}

// Concrete Factories
class CarFactory extends VehicleFactory {
  createVehicle() {
    return new Car();  // Create a Car
  }
}

class BikeFactory extends VehicleFactory {
  createVehicle() {
    return new Bike();  // Create a Bike
  }
}

class TruckFactory extends VehicleFactory {
  createVehicle() {
    return new Truck();  // Create a Truck
  }
}

// Client code
function getVehicle(factory) {
  const vehicle = factory.createVehicle();  // Uses the factory method
  console.log(vehicle.manufacture());
}

// Using the factory to get different vehicles
const carFactory = new CarFactory();
const bikeFactory = new BikeFactory();
const truckFactory = new TruckFactory();

getVehicle(carFactory);   // Output: Manufacturing a Car.
getVehicle(bikeFactory);  // Output: Manufacturing a Bike.
getVehicle(truckFactory); // Output: Manufacturing a Truck.

If you want to add new vehicle type eg: "Bus" you can add without changing the client code, making system more flexible and maintainable.

Factory : An abstract class or interface creates objects without specifying the exact class. Subclasses decide which class to instantiate, making the code flexible and easier to maintain.
Abstract Class: Cannot be instantiated directly. It provides a template with both abstract (no implementation) and concrete (with implementation) methods.
Concrete class : It is a class in object-oriented programming that can be instantiated, meaning you can create objects from it. Unlike abstract classes, which may have unimplemented methods, a concrete class provides full implementations for all its methods. This makes it a complete blueprint that can be used to create instances.

Use Case

// Step 1: Define the DatabaseConnection interface
public interface DatabaseConnection {
    void connect();
}

// Step 2: Implement concrete classes for different databases
public class MySQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to MySQL database...");
    }
}

public class PostgreSQLConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to PostgreSQL database...");
    }
}

public class SQLiteConnection implements DatabaseConnection {
    @Override
    public void connect() {
        System.out.println("Connecting to SQLite database...");
    }
}

// Step 3: Create an abstract factory class
public abstract class DatabaseConnectionFactory {
    public abstract DatabaseConnection createConnection();
}

// Step 4: Implement factory classes for each database type
public class MySQLConnectionFactory extends DatabaseConnectionFactory {
    @Override
    public DatabaseConnection createConnection() {
        return new MySQLConnection();
    }
}

public class PostgreSQLConnectionFactory extends DatabaseConnectionFactory {
    @Override
    public DatabaseConnection createConnection() {
        return new PostgreSQLConnection();
    }
}

public class SQLiteConnectionFactory extends DatabaseConnectionFactory {
    @Override
    public DatabaseConnection createConnection() {
        return new SQLiteConnection();
    }
}

// Step 5: Use the factory to create database connections
public class Main {
    public static void main(String[] args) {
        DatabaseConnectionFactory factory;

        // Example: Creating a MySQL connection
        factory = new MySQLConnectionFactory();
        DatabaseConnection mySQLConnection = factory.createConnection();
        mySQLConnection.connect();

        // Example: Creating a PostgreSQL connection
        factory = new PostgreSQLConnectionFactory();
        DatabaseConnection postgreSQLConnection = factory.createConnection();
        postgreSQLConnection.connect();

        // Example: Creating a SQLite connection
        factory = new SQLiteConnectionFactory();
        DatabaseConnection sqliteConnection = factory.createConnection();
        sqliteConnection.connect();
    }
}

In this example:
DatabaseConnection is the interface for different types of database connections.
MySQLConnection, PostgreSQLConnection, and SQLiteConnection are concrete implementations of the DatabaseConnection interface.
DatabaseConnectionFactory is an abstract factory class with a method createConnection().
MySQLConnectionFactory, PostgreSQLConnectionFactory, and SQLiteConnectionFactory are concrete factory classes that create specific database connections.

This pattern allows you to create database connections without specifying the exact class, making the code more flexible and easier to maintain.

Entity Relationship Diagram[ERD]

eXpLorE wItH mE — Tue, 19 Nov 2024 09:48:02 +0000

Entity Relationship Diagram / Entity Relationship Models
Entity is a distinct object or thing in the real world that can be identified and stored in a database. It is the fundamental to database and represents main object.

Customer: In an online store, a customer is an entity. Attributes might include CustomerID, Name, Email, and Address.
Book: In a library system, a book is an entity. Attributes might include BookID, Title, Author, and ISBN.
Order: In an e-commerce platform, an order is an entity. Attributes might include OrderID, OrderDate, and TotalAmount.

ERD is a visual representation of the entities within the system and the relationships between those entities. Helps to organize and structure data effectively.

Why

They help in organizing data, identifying relationships between entities, and ensuring a clear, efficient database design.
This makes it easier to understand, communicate, and implement the database.

Symbols Used in ER Diagrams

Cardinality

It specifies the number of instances of one entity that can or must be associated with each instance of another entity. It helps define the nature of the relationships between entities in a database.

Keys

Specialization and generalization are two opposite processes in database design and entity-relationship modeling.

Limitations of ER diagrams and models

Limited Detail: Can't show complex relationships well.
Static: Doesn't capture changes over time.
Varied Notations: Different symbols can cause confusion.
No Logic: Doesn't show how data is used or manipulated.
Cluttered: Gets messy with large databases.

Database Normalization

eXpLorE wItH mE — Tue, 19 Nov 2024 07:18:23 +0000

Database normalization organizes data in a structured and consistent way, eliminating redundancy and ensuring data integrity within relational databases. It makes databases easier to manage, query, and maintain, reducing errors.
By following normalization rules, you can design databases that are easier to maintain and less prone to errors.

Before dive into the normalization we wanted to know the basics of the relational database.

A relational database is a type of database that stores data in tables, which are structured into rows and columns. Table - Collections of related data entries Rows - Records, each row represents a single data Columns - Fields, each column represents a specific attribute of the data.

Primary Key - A unique identifier for each row in a table. Ensures each record can be uniquely identified.
Foreign Key - A field in one table that links to the primary key of another table, creating a relationship between the two tables

We have mentioned that normalization is for eliminating redundancy and inconsistent dependency. What’s that?

Redundant data means storing the same data in multiple places, which wastes disk space and creates maintenance problems. If any changes occur in the data, we have to update it in all places.

Inconsistent dependency happens when data in a database relies on other data in a way that is unpredictable or incorrect. This can cause errors and make the database unreliable.

Normal form - Each rule in database normalization. If a database follows the first rule of normalization, it’s in “First Normal Form” (1NF). If it follows the first three rules, it’s in “Third Normal Form” (3NF).

Think of normal forms as checkpoints/rule in a process, similar to how a driving test has stages like learners, parking, and road test.

First Normal Form (1NF)

Eliminate repeating groups in individual tables.

Create a separate table for each set of related data.

To normalize this data, we create separate tables for students and their courses:

Identify each set of related data with a primary key.

Second Normal Form (2NF)

Remove partial dependency — Every non-key column must depend on the whole primary key, not just part of it.

The 1NF only eliminates repeating groups, not redundancy. That’s why there is 2NF.

A table is said to be in 2NF if it meets the following criteria:
it’s already in 1NF
No partial dependency. That is, all non-key attributes are fully dependent on a primary key.

Third Normal Form (3NF)

Removes transitive dependencies by ensuring that non-key attributes depend only on the primary key.
Now we need to understand transitive dependency, which is key to understanding 3NF.

Transitive dependency happens when an attribute(column) depends on another non-key attribute rather than directly depending on the primary key.

3NF requires

The table is already is 2 NF
There are no transitive dependencies. This means that non-key attributes should not depend on other non-key attributes.

This is the final structure in 3NF:
No partial dependency (because all attributes are fully dependent on the whole primary key in their respective tables).
No transitive dependency (because no non-key attributes depend on other non-key attributes).

Elementary key Normal Form (EKNF)

EKNF is a stricter form of 3NF that ensures all functional dependencies are elementary, meaning they are straightforward and clear, without any complex dependencies.

3NF: Ensures no transitive dependencies.
EKNF: Further refines 3NF by ensuring all functional dependencies are elementary, addressing more complex dependencies that 3NF might not handle.

Boyce–Codd Normal Form(BCNF)

A table is in BCNF if:
1. It is in 3NF.
2. For every functional dependency ( A —> B ),A must be a candidate key (superkey).
Superkey: A set of one or more columns that can uniquely identify a row in a table.
Functional Dependency: A relationship where one attribute uniquely determines another attribute.

Fourth Normal Form (4NF)

Next level of normal form after BCNF.
Other Normal forms are concerned with functional dependencies, 4NF is concerned with a more general type of dependency known as a multivalued dependency.
Multivalued dependency - Occurs when one attribute determines multiple values of another attribute independently of other attributes.

Fifth Normal Form (5NF)

It is also known as Project-Join Normal Form (PJNF), is the highest level of normalization. A table is in 5NF if it is already in 4NF and cannot be decomposed into smaller tables without losing data integrity. This means that every non-trivial join dependency in the table is implied by the candidate keys.
If we decompose this table into smaller tables to eliminate redundancy, we must ensure that we can still reconstruct the original table without losing any information. In 5NF, this decomposition is done in such a way that no information is lost, and all join dependencies are preserved. explain wit examples

Denormalization

Tables may be denormalized to improve performance.
Normalization increases the number of tables & relationships.
Accessing multiple tables across relationships requires more processing than accessing a single table.

Design Pattern

eXpLorE wItH mE — Mon, 18 Nov 2024 07:51:02 +0000

Design Pattern is a general reusable solution to a common problem in software design.
Blue print that you can follow to solve a particular design issue in the code.
It is not specific to any programming language and can be applied in various contexts.
The pattern is not a specific piece of code, but a general concept for solving a particular problem. You can follow the pattern details and implement a solution that suits the realities of your own program.
In 1994, four authors published Design Patterns: Elements of Reusable Object-Oriented Software. It introduced design patterns for solving programming problems and became very popular. People often call it “the GoF book” (short for “Gang of Four”).

Patterns are often confused with algorithms.
Algorithm: A step-by-step procedure to solve a specific problem. It’s like a recipe with exact steps.
Design Pattern: A general solution to a common problem in software design. It’s more like a blueprint that can be adapted to different situations.

Why?

Reusability: Design patterns provide solutions that can be reused in different parts of your application or in different projects.
Efficiency: They help you solve problems more quickly by providing a tried-and-tested approach.
Maintainability: Code that follows design patterns is often easier to understand, maintain, and extend.
Communication: They provide a common vocabulary for developers, making it easier to discuss and share design ideas.

How?

Identify the problem
Choose the right pattern
Implement the pattern

Types

1. Creational Design Patterns -> Focus on the process of object creation or problems related to object creation. It help in creating objects in a flexible and efficient way. They control how objects are created to reduce complexity and increase flexibility.

2. Structural Design Pattern -> Focus on how classes and objects are composed to form larger structures. They help ensure that when changes are made in one part of a system, other parts remain unaffected, making the system more flexible and easier to maintain.

3. Behavioral design patterns -> Focus on how objects interact and communicate with each other. They help manage complex control flows and ensure that objects work together efficiently. It concerned with algorithms and the assignment of responsibilities between objects.

Drawbacks

1. Complexity: Implementing design patterns can sometimes add unnecessary complexity to the code.
2. Learning Curve: They can be difficult for beginners to understand and apply correctly.
3. Overhead: Some patterns may introduce performance overhead.
4. Rigidity: Overuse of patterns can make the code rigid and harder to modify.
5. Inappropriate Use: Using the wrong pattern for a problem can lead to inefficient solutions.

.git

eXpLorE wItH mE — Thu, 14 Nov 2024 08:20:58 +0000

Git is a Version Control System that keep track of changes to your files & collaborate with others on project.
Git is a Content Addressable Filesystem - Git is a simple key-value data store. Git is like a special storage system where you can save any content (like files or data). When you save something in Git, it gives you a unique key (a SHA-1 hash - 40-character strings) for that content. You can use this key to retrieve the exact content you saved whenever you need it.

Imagine you have a library where every book is given a unique code. When you want to find a book, you just use its code to locate it. Similarly, in Git, you save a file, get a unique key, and use that key to get the file back whenever you need it.

git init is a command that initializes a new Git repository. When you run this command in a directory, it sets up the necessary files and structure for Git to start tracking changes in that directory.

Steps and Effects of Running git init

Creation of the .git Directory - Git creates a hidden .git directory in the root of your project. This directory contains all the metadata and object database for your repository.
Initialization of Default Files - Inside the .git directory, Git sets up various files and subdirectories needed to manage the repository. This includes configuration files, an object database, and references.
Setting Up the Initial Branch - Git sets up the initial branch, usually named main. This branch will be the default branch where your commits will be made initially.
After initializing a repository, you can use other Git commands like git add, git commit, git push, etc. Without initializing, these commands won’t work because Git doesn’t know where to store the version history.
By initializing a repository, you can later connect it to a remote repository (e.g., on GitHub) to collaborate with others. This allows multiple people to work on the same project simultaneously.

Imagine you’re starting a new group project for a school assignment. You create a folder on your computer for the project files. By running git init in that folder, you set up a system to keep track of every change you and your teammates make. This way, if someone accidentally deletes an important file or makes a mistake, you can easily revert to a previous version. It also helps you see who made which changes and when, making collaboration smoother and more organized.

What's inside .git

The core components of the .git directory are the objects, which are fundamental to how Git tracks changes.

$ tree .git

.git
├── config
├── HEAD
├── hooks
│   └── prepare-commit-msg.msample
├── objects
│   ├── info
│   └── pack
└── refs
    ├── heads
    └── tags

We’ll also look at the .git directory structure after the commit. Let’s add a text file named gitText.txt and commit it. This process will return a unique ID for the commit.

Add the File to the Staging Area && Commit the File: The commit returns a unique ID (ad35fe3 in this case) that you can use to reference this specific commit.

C:\git-project>git add .
C:\git-project>git commit -m "added text file"
[master (root-commit) ad35fe3] added text file
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 gitText.txt

.git file structure after the commit

After the commit, the file structure changed. Some more files were added and data was updated. We will check them one by one.

index - Staging area, The index file contains metadata information for staging. Once staged, it gathers all the data related to the added files. Think of it as a draft space where you can review and organize your changes.

HEAD - Tracks the current branch or commit. It updates automatically when you switch branches or checkout a commit.

Think of the HEAD file as a bookmark in a book. The bookmark tells you which page (branch or commit) you are currently on.

description - Gives a short description of the repository. A Git repository is like a digital storage space where all the files and their history for a project are kept. It helps developers track changes, collaborate with others, and revert to previous versions if needed.

config - Text file that contains your git configuration for the current repo. If you look into it, you would see some basic settings for you repo like the author, filemode etc.

COMMIT_EDITMSG - It contains the (last) commit message.

refs - In Git, refs (references) are pointers to commits, making it easier to manage your repository. They are stored in the .git/refs directory and help keep track of branches, tags, and remote branches. Each ref file contains the commit hash it points to, helping you navigate and manage your project’s history.

objects - The objects directory in Git stores data about your files and commits.

Git objects are the core components that Git uses to store and manage your project’s data. These objects are stored in a compressed format to save space and improve performance

1. Blob(Binary Large Object): Think of a blob as a snapshot of a file. Every time you save a file in Git, it creates a blob to store that version of the file. It saves only the file content.
2. Tree: A tree is like a folder. It keeps track of blobs (files) and other trees (subfolders). It helps Git understand the structure of your project.
3. Commit: It captures the state of your project at a specific moment. It includes information about what changes were made, who made them, and when.
4. Tag: A tag is a label you can put on a specific commit. It’s like bookmarking a particular version of your project, often used for marking releases.
Here’s how it works: Use the git log command to see all your commits.

Each commit has a unique ID called a SHA-1 hash, which is a 40-character string. For example, let’s take a commit with the ID 8d168052de87b8bd8b71211383cd17457f0e2267. Git takes the first two characters (8d) and creates a folder named 8d inside the objects directory. Inside this 8d folder, Git creates a file named 168052de87b8bd8b71211383cd17457f0e2267.

This file contains all the information about that specific commit. This structure helps Git organize and find commit data efficiently.

objects/
├── 8d/
│   └── 168052de87b8bd8b71211383cd17457f0e2267

logs - Git logs track the changes made to your refs over time. They help you understand the sequence of commits and actions taken in your repository.

info - Additional configuration for your Git repository. The most important file here is exclude, which works like a .gitignore file but is specific to your local repository. You can use it to specify files and directories that Git should ignore, without sharing these rules with others. For example, if you want Git to ignore all .log files, you can add *.log to the info/exclude file. This helps keep your repository clean by excluding unnecessary files from being tracked.

hooks - It contain any scripts that can be run before/after git does anything. It is like a little helper to automate the tasks.
Client-side hooks - which run on your local machine and are triggered by actions like committing or merging
Server-side hooks - which run on the server where your repository is hosted and are triggered by actions like pushing commits (e.g., pre-receive to enforce rules before accepting commits).
To use a hook, you typically rename a sample script in the .git/hooks directory by removing the .sample extension and making it executable. This allows you to customize and automate your Git workflow effectively.

NGINX

eXpLorE wItH mE — Tue, 12 Nov 2024 11:52:25 +0000

Nginx is a web server that can also be used as a reverse proxy, load balancer, mail proxy and HTTP cache. Oops, it is a lot of information. Don't worry we will check one by one in the below section.

Reverse Proxy

Forward Proxy - A forward proxy server acts as an intermediary between a client and the internet. It sends requests on behalf of the client, hiding the client’s identity and sometimes controlling access to certain websites.

Imagine you want to buy a book without revealing your identity. You ask a friend to buy it for you. Your friend goes to the bookstore, buys the book, and brings it back to you. Here, your friend is like a forward proxy, hiding your identity from the bookstore.

Reverse Proxy - A reverse proxy server sits in front of web servers and forwards client requests to the appropriate server. It helps manage traffic, improve security, and balance the load on the servers.

Think of a popular restaurant with a host at the entrance. Guests tell the host their orders, and the host communicates with the kitchen. The host then brings the food back to the guests. In this case, the host acts as a reverse proxy, managing and directing requests to the kitchen and back to the guests.

Reverse Proxy: Hides the information of the server. It sits in front of the server and handles incoming client requests, forwarding them to the appropriate server while masking the server's identity.

Forward Proxy: Hides the information of the client. It sits in front of the client and forwards their requests to the web servers, masking the client's identity.

Load Balance

Method in which it spreads incoming traffic across multiple servers to prevent any single server from getting overwhelmed, ensuring better performance and reliability.

Imagine an online store during a big sale. Instead of all customers being served by one cashier, multiple cashiers are available to help, reducing wait times and keeping things running smoothly.

Mail proxy

Server that sits between email clients (like your email app) and email servers. It helps manage and route email traffic, ensuring emails are delivered efficiently and securely.

Think of it like a post office that sorts and directs mail to the correct addresses, making sure everything gets to where it needs to go without delays. When you send an email, the mail proxy checks it and then forwards it to the recipient’s email server, ensuring it reaches the right destination quickly and safely.

HTTP Cache

System that stores copies of web content (like images, HTML pages, and files) to serve them quickly to users. This reduces the need to fetch the same data repeatedly from the server, speeding up load times and reducing server load.

Think of it like a library that keeps popular books on hand so you don’t have to wait for them to be ordered every time someone wants to read them. When you visit a website, the images and files are stored in the cache. The next time you visit, the site loads faster because it uses the stored copies instead of downloading everything again.

Nginx is a versatile tool that serves web pages, acts as a reverse proxy, balances traffic across servers, manages email routing, and caches content for faster delivery. It is fast, efficient and easy to set up making it great choice for managing web traffic.

Understanding SSL/TLS: The Role of Encryption and Security Protocols in Internet Communication

eXpLorE wItH mE — Tue, 12 Nov 2024 10:49:31 +0000

SSL is Encryption based internet security protocol. Encryption - Process of converting information or data into a code to prevent unauthorized access. Protocol - A set of rules or procedures for transmitting data between electronic devices.

So first we need to know what is Encryption.

We need to ensure that data is transferred securely and only authorized people can access it.

Example: Imagine sending a letter to a friend. You lock it in a box with a special key (encryption), making it unreadable to others. You send the box, and even if someone intercepts it, they can’t open it without the key. When your friend gets the box, they use their matching key (decryption) to unlock it and read the letter.

Data encryption is the process of converting data from a readable format to scrambled piece of information that only be read or processed after its been decrypted.

Cryptography is the science of encrypting and decrypting data to prevent unauthorized access.

Symmetric Encryption Method

Also called Private-key cryptography/secret key algorithm
Process of using a single key(Private key) to both encrypt and decrypt data. Both the sender and receiver of the message need to have a pre-shared secret key that they will use to convert the plaintext into ciphertext and vice versa.
The key must be kept private and be known only to the sender and the receiver.

Imagine you have a lockbox where you keep your important documents. You and your friend both have a key to this lockbox. This key is the same for both of you, and it’s the only way to open the lockbox.

In symmetric encryption:

The lockbox represents the data you want to protect.

The key represents the secret code used to encrypt and decrypt the data.

Here’s how it works:

Encrypting: When you want to send a secret message to your friend, you put the message in the lockbox and lock it with the key. This is like converting your readable message into a coded format that only someone with the key can understand.

Decrypting: Your friend receives the lockbox and uses their copy of the key to unlock it and read the message. This is like converting the coded message back into its original, readable format.

The key point is that both you and your friend use the same key for both locking (encrypting) and unlocking (decrypting) the message. This is why it’s called “symmetric” encryption.

Asymmetric Encryption Method

Public-key cryptography
Uses two keys for the encryption process, a public and a private key, which are mathematically linked. The user employs one key for encryption and the other for decryption, though it doesn’t matter which you choose first.
As the name implies, the public key is freely available to anyone, whereas the private key remains with the intended recipients only, who need it to decipher the messages. Both keys are simply large numbers that aren’t identical but are paired with each other, which is where the “asymmetric” part comes in.

Imagine you have a mailbox with a special lock. This lock has two keys:

A public key that anyone can use to lock (encrypt) the mailbox.

A private key that only you have, which can unlock (decrypt) the mailbox.

Here’s how it works:

Public Key (Locking): You give your public key to anyone who wants to send you a message. They use this key to lock (encrypt) the message and put it in your mailbox. Since the public key is only for locking, it doesn’t matter if others see it.

Private Key (Unlocking): When you receive the locked message, you use your private key to unlock (decrypt) it and read the message. Only you have the private key, so only you can unlock the mailbox and read the messages.

`
Public Key: Think of it as your email address. You can share it with anyone, and they can send you emails.

Private Key: This is like your email password. Only you know it, and it allows you to access your emails.`

When someone wants to send data, they will retrieve the recipient’s public key from a public directory and use it for encryption before sending. The recipient can then decrypt the message using their corresponding private (secret) key.
Many protocols rely on asymmetric cryptography, including Transport Layer Security (TLS) and Secure Sockets Layer (SSL), which make HTTPS possible.
Asymmetric cryptography is typically used to authenticate data using digital signatures.

Digital Signatures

A digital signature is like a virtual fingerprint, stamped seal or a handwritten signature, but for digital documents. It ensures that the document is authentic and hasn’t been altered.
Here’s how it works:

Creating a Signature: When you sign a document digitally, a unique code (called a hash) is created from the document’s contents.
Encrypting the Hash: This hash is then encrypted using your private key (more on keys below). This encrypted hash is your digital signature.
Verifying the Signature: When someone receives the document, they can use your public key to decrypt the hash. They then create a new hash from the document and compare it to the decrypted hash. If they match, the document is verified as authentic and unaltered.

Imagine you want to send a secure email to a friend:

You write the email and create a hash of its contents.

You encrypt the hash with your private key to create a digital signature.

You send the email along with your digital signature.

Your friend receives the email and uses your public key to decrypt the signature.

They create a new hash from the email and compare it to the decrypted hash. If they match, your friend knows the email is from you and hasn’t been changed.

Hashing

Hashing is like creating a unique fingerprint for a piece of data or a message(a fixed-length string of characters).
Even a tiny change in the original data will result in a completely different hash, making it easy to spot alterations.
Once data is hashed, you can’t reverse it back to the original form. This makes hashing great for verifying data integrity.
Not Encryption: Hashing isn’t really encryption because you can’t decrypt it. It’s just a way to check that the data is the same as it was originally.

Hashing is used to verify the integrity of data, ensuring it hasn’t been altered. While it’s not exactly the same as authentication (which confirms the identity of a user), hashing helps confirm that the data is exactly what it should be.

Encryption for Internet browser secure

HTTP is application layer protocol like a conversation between browser & web server. Browser asks for a webpage (request), and the server sends it back (response). This simple process allows you to browse the internet.
HTTPS (Hypertext Transfer Protocol Secure) is the secure version of HTTP.
HTTPS uses a protocol called TLS-Transport Layer Security (formerly SSL-Secure Sockets Layer) to encrypt communications. This protocol secures data by using an asymmetric system with two keys: a public key and a private key.
HTTPS uses port 443 and for HTTP it is 80.
A Certificate Authority (CA) is a trusted organization that issues digital certificates. These certificates are used to verify the identity of websites and other entities on the internet. Essentially, CAs act as a trusted third party that both the website owner and the user can rely on.

When you visit a website, your browser checks the certificate to ensure it’s valid and issued by a trusted CA. If everything checks out, the browser establishes a secure connection.

The SSL/TLS handshake is a process that establishes a secure connection between a client (like a web browser) and a server (like a website). During this handshake, the client and server exchange cryptographic keys and agree on encryption methods to ensure data privacy and integrity. The process involves several steps: the client sends a “ClientHello” message to the server, the server responds with a “ServerHello” message, and both parties exchange certificates to authenticate each other. They then generate session keys used to encrypt the data transmitted during the session. This handshake ensures that any data exchanged is secure and protected from eavesdropping or tampering.

Redis: Understanding the Basics

eXpLorE wItH mE — Mon, 11 Nov 2024 09:26:46 +0000

REDIS - Remote Dictionary Server

Open Source, advanced key-value store.
It supports various data structures such as strings, hashes, lists, sets, and sorted sets.
Redis is known for its high performance, flexibility, and ease of use, making it a popular choice for developers.

Why

The real question is, why do we need Redis? For example, in apps like LinkedIn, Facebook, or Instagram, loading large amounts of data (such as profile pictures, names, followers, and posts) from the database can be slow, especially if the user refreshes the page frequently. Redis helps by caching the data after the first load, so subsequent requests fetch the stored data quickly, improving the user experience.

Redis

In-memory data structure store used as a database, cache, and message broker. Good for building high performance, scalable web applications.
When we say “everything is in-memory” with Redis, it means that all the data is stored in the computer’s RAM (Random Access Memory) instead of on a hard drive. This makes data access extremely fast because RAM is much quicker to read from and write to compared to a hard drive.
It is often referred to as a data structure server, since the keys can contain strings, hashes, lists, sets and sorted sets.
Redis is written in C.

Data Types

Strings: The simplest type, storing text or binary data. Think of it like a single piece of information, such as a name or a number.
Lists: Ordered collections of strings. Imagine a to-do list where you can add, remove, and access items by their position.
Sets: Unordered collections of unique strings. Useful for storing items where duplicates aren’t allowed, like a list of unique tags.
Sorted Sets: Similar to sets but with a score assigned to each item, allowing them to be sorted. Great for leaderboards where you need to rank items.
Hashes: Maps of fields and values, like a dictionary. Perfect for storing objects with multiple attributes, such as user profiles.
Bitmaps: Strings that can be treated as arrays of bits, useful for tracking binary states, like user activity.
HyperLogLogs: Probabilistic data structures for counting unique items with minimal memory usage. Handy for large-scale analytics.
Streams: Log-like data structures for storing sequences of messages, useful for real-time data processing.

Redis Replication - Redis can create copies of its data on multiple other Redis servers, called “slaves.” This process is known as replication. The main server, called the “master,” sends updates to all its slaves. This way, if the master server goes down, one of the slaves can take over, ensuring that your data is always available and safe.

Pub/Sub - It is like a messaging system, where the senders(publishers) sends the messaged while the receivers(subscribers) receive them through channel. A client can subscribe any number of channels.

Redis can be secured so that any client making a connection needs to authenticate before executing commands. To secure Redis, you need to set a password in the configuration file. After setting the password, if a client tries to run a command without authentication, they will receive an (error) NOAUTH Authentication required error. Therefore, the client must use the AUTH command to authenticate.

Redis Persistence

Persistence refers to the ability to save data to disk so that it can be recovered after a restart or crash. This ensures that your data is not lost and can be restored to its previous state.
2 main methods for persistence: RDB and AOF.

1. RDB (Redis Database Backup) - Creates a snapshot of the entire dataset at configured intervals. Saves the snapshot to disk as a binary file. Efficient and quick to load. Minimal impact on performance during snapshot creation.
Example - An e-commerce website uses RDB to take snapshots of user sessions and shopping carts every 15 minutes for quick recovery.
Drawbacks - Risk of data loss between snapshots. Not suitable for applications requiring high durability.

2. AOF (Append Only File) - Logs every write operation received by the server. Periodically rewrites the AOF file to keep it compact. Higher durability with less risk of data loss.
Example - A financial transaction system uses AOF to log every transaction immediately, ensuring high durability and minimal data loss.
Drawbacks - Larger file size compared to RDB. Slower performance due to logging every operation.

Redis allows you to use both RDB and AOF together to combine the benefits of both methods, providing a balance between performance and data safety.

Redis Sharding

Redis Sharding is a way to split your data across multiple Redis servers to handle more data and traffic efficiently.
Imagine you have a library with thousands of books. If all the books are stored in one room, it can get crowded and slow to find a book. To solve this, you can split the books into different rooms based on their genres. Now, each room has fewer books, making it faster to find what you need.
In Redis, sharding works similarly. Instead of storing all data on one server, you split it across multiple servers (shards). Each shard handles a portion of the data, making the system faster and more scalable.

Disadvantages

Memory Usage: Redis stores all data in RAM, which can be costly for large datasets.
Single-Threaded: Redis runs on a single thread, which can limit performance for CPU-intensive tasks.
Basic Security: Redis has limited built-in security features, which might not be enough for sensitive data.
No Complex Queries: Redis doesn’t support complex queries like SQL databases do.
Risk of Data Loss: Since Redis is primarily in-memory, there’s a risk of data loss if the server crashes before data is saved to disk.