Forem: Atul Kushwaha

hey guys i have been learning linear algebra from a great teacher and friend of mine, in such a way that i was able to see a linear transformation happening in my mind should i make a series of blogs on LA ?

Atul Kushwaha — Thu, 12 Feb 2026 06:58:01 +0000

Context Switch 🔁 in REAL life

Atul Kushwaha — Tue, 10 Feb 2026 08:15:57 +0000

ONLY THE BANNER IS AI GENERATED, BLOG ISN'T

I love computer science because it is so practical. I recently experienced a real-life example of a context switch. It’s a great analogy to explain what a context switch is and why the time quantum in Round Robin scheduling shouldn't be too small.

Key Concepts

Context Switch: is defined as the procedure of Saving the state of the Old Process and Loading the state of the New Process
PCB (Process Control Block): A PCB is created for every individual process by the OS to track various parameters, such as the last executed statement (using the Program Counter), registers being used, and the data or files accessed by the process.
Degree of Multiprogramming: This refers to the number of processes present in the Ready State.

The Exam Analogy

I recently sat for the GATE 2026 exam. Imagine you are in the examination room. A common strategy we follow is this: you start solving a question but realize midway that it will take a huge chunk of your time. If you stayed on it, you would be blocked from answering other, easier questions btw, this is essentially the Convoy Effect seen in FCFS (First-Come, First-Served) scheduling (i.e Process with large burst time blocking processes with significantly lesser burst time)

To avoid this, you leave the question half-solved and jump to another. This is essentially a context switch. Leaving the question is equivalent to saving its context (i.e., leaving the page in your scribble pad where you were working so the half-solved answer remains there).

In an OS, there are several reasons to perform a context switch:

Higher Priority Process: Similar to realizing the current question is worth 1 mark, but there are 2-mark questions left.
Interrupts: Similar to an invigilator coming to your desk for an attendance sheet signature. etc etc....

Saving and Loading Context

let's say now the next question you are solving is new, i.e you haven't read that question yet, so there is nothing you know about the question and hence nothing to retrieve from brain (except obv the concepts you'd use to solve it) btw this can also be seen as runtime environment

Runtime environment, manages essential tasks like memory allocation, dynamic linking, and resource access (e.g., files, networks, I/O devices), independent of the specific OS.

coming back, so a this action is same as switching to a new process in terms of OS, you save the context of the current process in its PCB.

Similarly, in an exam, when you switch to a new question, you are saving the context of your current work simply by leaving it as is. Since the next question is new, there is no need to "load" a previous context because it does not yet exist; instead, you initiate a new context by reading the question and writing down the given data.

However, if you switch back to a question you left earlier, it is equivalent to saving the current context and loading the context of the old, partially executed process in terms of OS. Just as the half-solved answer on your scribble pad is the "context" that needs to be loaded back into your brain to resume solving the earlier left question, the OS retrieves the saved state from the PCB to continue execution of earlier partially executed process.

Small Qt in Round Robbin

Now, imagine there are only 10 minutes left. In a panic, you start a question, realize it’s too long, switch to another, realize the same, and switch again. You are now acting like a Round Robin algorithm with an extremely small time quantum. You end up spending more time switching between questions (the overhead) than actually solving them.

also, If the invigilator takes your paper away because time is up, that is a Preemptive Context Switch. You didn't choose to leave the question; the OS (Invigilator) forced you out because your 'Time Quantum' expired.

also If you’ve ever struggled to differentiate between these two:

Parallel vs. Concurrent Execution

Parallel Execution: This is only possible with multiple CPUs or multiple cores within a CPU. It would mean solving three questions simultaneously at the same time while its possible for CPU's with multiple cores not possible for us humans as we only have 1 brain (cpu)
Concurrent Execution: as human being's we only have a single brain(CPU), we can only work on a single task at a time, here i was not solving questions parallelly but concurrently i.e., solving multiple question in an interleaved fashion so i could cover maximum questions and making sure that my time utilization is maximum

which is the sole goal of concurrent programming i.e. executing multiple process concurrently in an interleaved fashion so that the CPU utilization can be maximized

Free custom domain for your projects 😉

Atul Kushwaha — Sun, 04 May 2025 11:10:33 +0000

The GitHub Student Developer Pack offers students free access to premium developer tools and services, including cloud credits, CI/CD platforms, and more. Follow this step-by-step guide to join the program, unlock these benefits, and claim a free domain from Namecheap.

Step 1: Join the GitHub Student Developer Pack

Verify Your Student Status

To qualify for the GitHub Student Developer Pack, you must be a current student (at least 13 years old) enrolled in a degree or diploma-granting program. Here's how to confirm eligibility:

Check Requirements: Ensure you have a verifiable school-issued email address (e.g., ending in .edu) or other documentation like a student ID, transcript, or enrollment letter.
Prepare Documentation: If you don’t have a school email, gather a clear image or PDF of your student ID, transcript, or an official letter from your school stating your enrollment status.

Create or Log In to Your GitHub Account

You’ll need a GitHub account to apply for the pack.

Sign Up: If you don’t have an account, go to github.com and click “Sign up.” Follow the prompts to create a free account.
Log In: If you already have an account, log in with your credentials.

Navigate to the GitHub Education Page

Visit the GitHub Education website at education.github.com.
Scroll to the “GitHub Student Developer Pack” section and click Get the Pack or Get started.

Start the Application Process

On the GitHub Student Developer Pack page, click Get your pack.
You’ll be redirected to a form to verify your academic status.

Complete the Application Form

Fill out the application form with the following details:

Personal Information: Enter your full name and GitHub username.
School Email: Provide your school-issued email address if available. This is the fastest way to get verified.
Alternative Verification: If you don’t have a school email, select the option to upload documentation. Upload a clear image or PDF of your student ID, transcript, or enrollment letter.
Purpose: Briefly describe how you plan to use the Student Developer Pack (e.g., for coding projects, learning, or open-source contributions).

Submit Your Application

Review your information and uploaded documents (if applicable).
Click Submit to send your application to GitHub for review.

Wait for Verification

School Email: If you used a school-issued email, verification is often instant or takes a few hours.
Manual Review: If you uploaded documents, GitHub’s team will review them, which may take 1–5 business days.
You’ll receive an email notification once your application is approved or if additional information is needed.

Access Your Benefits

Once approved, you’ll gain access to the GitHub Student Developer Pack:

Log in to your GitHub account.
Visit education.github.com/pack to explore available tools and services.
Redeem offers by following the instructions for each partner (e.g., DigitalOcean, Heroku, or Namecheap). Some may require linking your GitHub account or signing up separately.

Renew Your Benefits (If Needed)

The Student Developer Pack is valid as long as you’re a student.
GitHub may periodically ask you to re-verify your student status. Follow the same process to upload updated documentation or confirm your enrollment.

Tips for a Smooth Application

Use a School Email: If available, this speeds up verification significantly.
Clear Documentation: Ensure uploaded documents are legible and include your name, school, and current enrollment date.
Check Spam Folder: GitHub’s response email may land in your spam or junk folder.
Contact Support: If you face issues or delays, reach out to GitHub Support via support.github.com.

Step 2: Avail a Free Domain from Namecheap

One of the many benefits of the GitHub Student Developer Pack is access to a free domain from Namecheap. Follow these steps to claim and set up your domain for use with GitHub Pages.

Claim the Free Domain: Among the benefits, you can claim a free .me domain from Namecheap. After claiming the domain, a repository named your-username.github.io will be created in your GitHub account.
Repository Contents: This repository will contain a CNAME file with your domain name as its content and a README file.
Note on SSL: For GitHub Pages, you don’t need to avail a free SSL certificate, as GitHub provides HTTPS automatically. However, if you plan to deploy your project elsewhere, you may need one, which is also freely available
validity of domain name: 1 year

Set Up the Domain in GitHub

Navigate to your GitHub account’s Settings > Pages.
Under the “Custom domain” section, click Add a domain.

Enter your domain name (e.g., yourname.me).
GitHub will prompt you to verify ownership of the domain.

Verify Domain Ownership with Namecheap

Log in to your Namecheap account.
Navigate to the Dashboard.
Find your domain and click Manage.

Go to the Advanced DNS tab.
Add a TXT record to verify ownership:
- Host: Use the value provided by GitHub (e.g., _github-pages-challenge-yourusername).
- Value: Enter the verification code provided by GitHub (e.g., 81e12bbe76d30d12897eea833d7ree).
- TTL: Set to 1 minute.
Save the changes.

Return to the GitHub Pages settings and click Verify. GitHub will check the TXT record to confirm ownership. This process may take up to 12 hours.

Add a CNAME Record (Optional)

In Namecheap’s Advanced DNS tab, you can also add a CNAME record to point your domain to GitHub Pages:
- Type: CNAME Record
- Host: www
- Value: your-username.github.io
- TTL: 1 min

Enable HTTPS

After 12 hours, once the domain is verified, it may show a “Connection not secure” warning.
To enable a secure HTTPS connection, navigate to the your-username.github.io repository’s Settings > Pages.
Check the box for Enforce HTTPS.

Conclusion

By joining the GitHub Student Developer Pack and claiming a free domain from Namecheap, you can enhance your development projects with professional tools and a custom domain. Follow these steps to set up your GitHub Pages site with a verified, secure domain. Start your journey today at education.github.com/pack/join!

create and deploy projects seemleasly

Atul Kushwaha — Fri, 02 May 2025 08:29:50 +0000

Atul Kushwaha

May 2 '25

Host Lovable.dev Project on github pages 😺

#github #tutorial #ai #webdev

Comments 24

3 min read

Host Lovable.dev Project on github pages 😺

Atul Kushwaha — Fri, 02 May 2025 08:28:42 +0000

Deploying a Lovable.dev Project to GitHub Pages

link to the blog to get free custom .me domain name Free custom domain for your projects 😉

Here is the link to my portfolio, generated by lovable.dev and hosted on GitHub Pages

Prerequisites

Before we begin, ensure you have the following:

Node.js (version 18 or higher) installed on your system.
Basic knowledge of Git and GitHub.

Step 1: Connect lovable.dev with GitHub

Click View on GitHub.
Clone this private project locally on your machine.
Open a terminal in your cloned repository location. First, we are going to remove all Git files. For Windows, type:

Remove-Item -Recurse -Force .git
# Check if Git files still exist
git status

This will remove all Git-related files from your project.
Now we can try running the project locally:

npm install       # Install all dependencies
npm run build
npm run dev

6.Make any changes to the code if needed.

Step 2: Create a New Repo for GitHub Pages and Update Config

Create a new repository, say coderatul-portfolio, on GitHub.
Clone this newly created repository to your machine.
Copy and paste all files from your original project (where Git was removed) to this new repo coderatul-portfolio.
You may now delete the initially cloned repository, as we have all source code where we need it.

Update `vite.config.ts`

The base property in the Vite configuration file (vite.config.ts) must be set to the repository name for GitHub Pages. This ensures that all asset paths are correctly resolved.

Example:

import { defineConfig } from "vite";
import react from "@vitejs/plugin-react-swc";
import path from "path";
import { componentTagger } from "lovable-tagger";

export default defineConfig(({ mode }) => ({
  server: {
    host: "::",
    port: 8080,
  },
  plugins: [
    react(),
    mode === 'development' &&
    componentTagger(),
  ].filter(Boolean),
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "./src"),
    },
  },
  base: '/coderatul-portfolio/' // Replace with your GitHub repo name
}));

Step 3: Push Code to GitHub and Set Up Workflow via GitHub Actions

Push the changes to your repository say coderatul-portfolio here:

git status
git add .
git commit -m "adding project"
git push -u origin main

Grant access for workflow: Visit https://github.com/<your-username>/<your-repository-name>/settings/actions, scroll down, make the necessary changes, and save.

In your repository, go to Settings > Pages

Select GitHub Actions
Then select GitHub Pages Jekyll and click Configure

Edit the workflow

Modify `workflow.yaml` as follows:

name: Deploy to GitHub Pages

on:
  push:
    branches:
      - main

permissions:
  id-token: write 
  contents: write 
  pages: write    

jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 18 

      - name: Vite GitHub Pages Deployer
        uses: skywarth/vite-github-pages-deployer@v1.5.0
        with:
          public_base_path: /coderatul-portfolio/  # Replace with your repository name
          build_path: ./dist
          install_phase_node_env: dev
          build_phase_node_env: production
          package_manager: npm
          artifact_name: github-pages
          debug_mode: false
          working_path: ./

Step 4: Verify the Deployment

Make appropriate changes, paste the modified workflow.yaml, commit it, and the workflow will start under the Actions tab.
Under Settings > Pages, you’ll see a live link to the deployed project.

What is a Workflow?

A workflow automates the process: any time you push code, GitHub Actions will automatically build and deploy your project. This is part of CI/CD.

Common Issues and Fixes

1. Blank Page After Deployment

Make sure the base property in vite.config.ts is correctly set to /repository-name/.
Clear browser cache or use incognito mode.

2. 403 Permission Errors

Ensure the GITHUB_TOKEN in your workflow has the correct permissions:

permissions:
  id-token: write
  contents: write
  pages: write

3. Asset Paths Not Resolving

Double-check the base property in vite.config.ts and ensure it matches your repo name.

Conclusion

Deploying a lovable.dev project to GitHub Pages is simple with the right setup. By setting the base path in vite.config.ts and automating deployment using GitHub Actions, you can publish your project effortlessly.

hey guys speed up your python code, especially with dynamic programming and recursive functions

Atul Kushwaha — Fri, 11 Apr 2025 08:01:59 +0000

Atul Kushwaha

Apr 11 '25

Cache in Python !

#python #cache #learning

Comments

3 min read

Cache in Python !

Atul Kushwaha — Fri, 11 Apr 2025 08:00:41 +0000

Exploring Python's `functools`: Cache, Cached Property, and LRU Cache

Python's functools module is a treasure trove for functional programming enthusiasts, offering tools to make your code more efficient and elegant. In this post, we'll dive into three powerful functions—cache, cached_property, and lru_cache—that help optimize performance by storing results of expensive computations. Whether you're speeding up recursive algorithms or simplifying class-based calculations, these tools have you covered. Let’s explore each one with clear explanations and practical examples.

1. `cache`: Simple, Unbounded Memoization

The cache decorator is a lightweight way to memoize function results, storing them for reuse when the same inputs occur again. It’s like a sticky note for your function’s outputs—no recomputation needed!

How It Works

What it does: Stores function results in an unbounded dictionary, using arguments as keys.
When to use it: Ideal for pure functions (same input, same output) that are computationally expensive.
Key feature: It’s equivalent to lru_cache(maxsize=None) but faster due to its simplicity.

Example

from functools import cache

@cache
def factorial(n):
    return n * factorial(n-1) if n else 1

print(factorial(10))  # Computes: 3628800
print(factorial(10))  # Returns cached result, no recomputation

Why It’s Awesome

Speed: Avoids redundant calculations, making recursive functions like factorial lightning-fast.
Simplicity: No configuration needed—just slap on the decorator.
Caveat: The cache grows indefinitely, so monitor memory usage for functions with many unique inputs.

2. `cached_property`: One-Time Property Computation

The cached_property decorator transforms a class method into a property that computes its value once and caches it for the instance. Think of it as a lazy-loaded attribute that sticks around.

How It Works

What it does: Runs the method the first time it’s accessed, caches the result as an instance attribute, and returns the cached value on subsequent calls.
When to use it: Perfect for expensive calculations in classes that don’t change after the first computation. Key feature: Works only with instance methods (requires self).

Example

from functools import cached_property

class Circle:
    def __init__(self, radius):
        self.radius = radius

    @cached_property
    def area(self):
        print("Computing area")
        return 3.14159 * self.radius ** 2

c = Circle(5)
print(c.area)  # Prints: Computing area, then 78.53975
print(c.area)  # Prints: 78.53975 (cached, no recomputation)

Why It’s Awesome

Efficiency: Computes only once per instance, saving CPU cycles.
Clean code: Reads like a property (c.area vs. c.area()), blending seamlessly into class design.
Caveat: The cached value can be overridden (e.g., c.area = 0), so use it for immutable data.

3. `lru_cache`: Flexible, Bounded Memoization

The lru_cache decorator is the heavy hitter of memoization, offering a Least Recently Used (LRU) cache with configurable size. It’s thread-safe and packed with introspection features, making it a go-to for optimizing complex functions.

How It Works

What it does: Caches up to maxsize results, evicting the least recently used entry when full. Supports a typed option to treat different types (e.g., 3 vs. 3.0) as distinct keys.
When to use it: Great for recursive algorithms, dynamic programming, or any function with repetitive calls.
Key feature: Provides cache_info() to inspect hits, misses, and cache size.

Example

from functools import lru_cache

@lru_cache(maxsize=32)
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(10))  # Computes: 55
print(fib.cache_info())  # Shows: CacheInfo(hits=8, misses=11, maxsize=32, currsize=11)

Why It’s Awesome

Control: Set maxsize to balance memory and performance (use None for unbounded, like cache).
Thread-safe: Safe for multithreaded applications, ensuring the cache stays consistent.
Debugging: cache_info() helps you tune performance by revealing cache effectiveness.
Caveat: Avoid using with functions that have side effects, as the cache assumes deterministic outputs.

Memory Handling in Java

Atul Kushwaha — Mon, 04 Mar 2024 13:19:15 +0000

Before diving into memory management of java one must know java has primitive datatypes and more complex objects (reference types)

Primitive type
refference type

Java has no concept of pointers and java only has pass by value, there is nothing like pass by reference in java

primitives

Primitive types are the basic data types provided by a programming language.
They are the simplest and most fundamental building blocks of data. In Java, the primitive types include:

Integral Types:
- byte: 8-bit signed integer
- short: 16-bit signed integer
- int: 32-bit signed integer -long: 64-bit signed integer
Floating-Point Types:
- float: 32-bit floating-point
- double: 64-bit floating-point
Characters:
- char: 16-bit Unicode character
Boolean:
- boolean: Represents true or false.

Reference type

Reference types are more complex and are used to store references (memory addresses) to objects. Objects are instances of classes or arrays. In Java, reference types include:

Objects:
- Instances of classes created using the new keyword.
Arrays:
- Ordered collections of elements.
Interfaces:
- Types representing a contract for classes to implement.

How primitives are stored ?

All data for primitive type variables is stored on the stack
when setting a primitive type variable equal to another primitive type variable, a copy of value is made.

int a  = 10;
int b = 20;
int c = b;
int c = 100;

int a = 10; -> int 10 is stored on stack memory
int b = 20; -> int 20 is stored on stack memory
int c = b; -> value of b(20) is copied to c
int c = 100; -> value of c is modified to 100

How Reference type stores value ?

For reference types, the stack holds a pointer to the object on the heap memory
When setting a reference type variable equal to another reference type variabel, a copy of only the pointer is made
Certain object types can't be manipulated on the heap(immutables)

int[ ] c = {1,2,3,4}; -> creates an array of integers in the heap memory and stack has a reference to that objetc in heap
int[ ] d = c; -> value of reference(stored in stack) is copied from variable c(stack) to variable d(stack), no new object is cretaed in the heap memory (and not the actual object)

d[1] = 99; -> value of object at index 1 is changed by variable d, which had reference of object {1,2,3,4,5} hence value is also changed for variable c, as they were having the same reference in the stack memory

d = new int[5]; -> a new array is created in th heap memory and d rerences to that new array
int[ ] e = {5,6,7,8} -> creates a new array in heap memory

int [ ] f = {5,6,7,8} -> also creates a new array in the heap although content of array e and fis same still the exist in various memory space

f[1] = 99 -> this would only change index at 1 position for array f and not for array e

String g = "hello"; -> a new string with value "hello" is created in the heap memory
String h = g; -> value of reference stored in stack memory is copied form g to h(and not the actual object object)

h = "goodbye"; -> you might be expecting that the value of string g should also have been changed as both g and h are pointing at same string, but as Strings are immutable meaning they can't be modified, so instead a new string "goodbye" is cretaed and it's reference is assigned to h and g still points to hello

for more reference and image credit

Thread synchronization in python's threading module

Atul Kushwaha — Fri, 01 Mar 2024 14:18:04 +0000

As we saw 👁️👁️ in our previous blogs, threading is susceptible to race conditions. To tackle race conditions, we may use locks and semaphores to manage synchronization and data consistency while using threads

There are 3 major techniques for thread synchronization

Lock 🔒

Rlock ®️🔒

Semaphore, BoundedSemaphore

Lock

A Lock is a basic synchronization primitive that provides exclusive access to a shared resource.
It has two states: locked and unlocked.
Only one thread can acquire the lock at a time. If another thread tries to acquire a locked lock, it will be blocked until the lock is released.
It is not reentrant, meaning that a thread holding the lock cannot acquire it again without releasing it first.

with context manager, manages acquiring and releasing lock for us, other wise we can use lock.acquire() and lock.release() methods as well

from threading import Lock

lock = Lock()

def example_function():
    with lock:
        # critical section
        pass

RLock (Reentrant Lock):

An RLock is an extension of the basic Lock that allows a thread to acquire the lock multiple times (reentrant).
A thread that already holds the lock can acquire it again without blocking, but it must release the lock the same number of times it acquired it.
Useful in situations where a function might need to acquire the same lock recursively.

from threading import RLock

rlock = RLock()

def example_function():
    with rlock:
        # critical section
        pass

Semaphore

A Semaphore is a more generalized synchronization primitive that allows a specified number of threads to access a shared resource concurrently.
It maintains a counter that is decremented each time a thread acquires it and incremented when the thread releases it.
Useful for controlling access to a resource with limited capacity.

from threading import Semaphore

semaphore = Semaphore(3)  # Allow up to 3 threads to access the resource concurrently

def example_function():
    with semaphore:
        # critical section
        pass

BoundedSemaphore

A BoundedSemaphore is similar to Semaphore but has an upper limit on its counter.
It raises a ValueError if the counter exceeds the specified bound when incremented.

from threading import BoundedSemaphore

bounded_semaphore = BoundedSemaphore(3)  # Bound the semaphore to allow up to 3 threads

def example_function():
    with bounded_semaphore:
        # critical section
        pass

conclusion

In summary, Lock and RLock provide exclusive access to a shared resource, while Semaphore and BoundedSemaphore allow a specified number of threads to access a shared resource concurrently. The choice between them depends on the synchronization requirements of your multithreaded application

Race condition in Python's threading🏁

Atul Kushwaha — Mon, 26 Feb 2024 05:00:00 +0000

we starting this blog let's quicky understand what's a race condition 🏎️

Race condition is everywhere, we can see this b/w top cloud providers like AWS, GCP, Azure to acquire the position of Top cloud provider > now, with context of threading Race condtion leads to unexpected outcomes when multiple threads try to access and manipulate a single shared resource (file, varibales etc)

intuitive doubt

In the context of threading, race conditions arise when multiple threads attempt to access and manipulate a shared resource, such as a file or variable.
You might wonder about the impact of the Global Interpreter Lock (GIL), which only allows one thread of a process to run at any given time. Despite this limitation, race conditions can still occur.

let's take an example to better understand

from threading import Thread, current_thread

class BookTicket():
    def __init__(self, available_seats):
        self.available_seats = available_seats

    def Bookseat(self, seatToBeBooked):
        print(f"{self.available_seats} seat was available before booking.")
        name = current_thread().name
        if seatToBeBooked <= self.available_seats:
            self.available_seats -= seatToBeBooked
            print(f"{seatToBeBooked} seat has been allocated to {name}")
        else:
            print("Sorry, we are out of seats.")

obj = BookTicket(1)
T1 = Thread(target=obj.Bookseat, kwargs={"seatToBeBooked": 1}, name="Walter White")
T2 = Thread(target=obj.Bookseat, kwargs={"seatToBeBooked": 1}, name="Jesse Pinkman")
T1.start()
T2.start()

quick explanation on what's going in above code

so we have two threads namely walter white and jesse pinkman, and these threads are trying to book a seat, if the seat is available they are alloated with a seat else we say sorry we don't have seats available.

initially we have only 1 seat available with us and first thread T1(walter white) and then thread T2(jesse pink man) threads are executed

now you might be expecting that we had 1 seat available, walter white would get that seat and after that we'd have 0 seats available for we'd say sorry jesse we don't have seats
well this could be true but not always

above we can see the expected output but due to race condition this is'nt always true,

above is an example of race contion or an unexpected behaviour

now, let's understand how race condition comes into picture even with GIL

so according to our expectations after 1 seat has been alloted to walter white
available seats should be 0, but it's 1 here and then it says sorry we are out of seats
ideally after printing out this 1 seat has been alloted to walter white, 1 seat should have been reduced and next printed statement should have been 0 seat was available before booking(as we only had one seat initially whihc was alloated to walter white)

but what really happened was after printing 1 seat has been alloted to walter white a context switch happened and thread (T2/jesse pinkman) started executing and because the number of seats available was'nt deducted by first thread (T1/walter while, due to context switch) we got an unexpected result which said 1 seat available before booking

and when again thread (T1/walter white) started executing from where it left before the context switch, number of available seats was subtracted now, then again context switch happened and thread (T2) started executing from where it left and as now the number of available seats was deducted by thraed T1, sorry we are out of seats was printed.

Threading vs Asyncio vs Multiprocessing

Atul Kushwaha — Thu, 22 Feb 2024 15:16:20 +0000

Before Diving into Differences: Threading, Asyncio, and Multiprocessing

Let's solidify our understanding of processes, threads, and context switching before delving into the intricacies of threading, asyncio, and multiprocessing.

Process:

A process is a program in execution. It's a set of instructions actively being carried out.
When a processor runs a program, that program becomes a process. It requires resources like RAM and I/O operations, provided by the operating system.
Each process has its own unique memory address space. This means a malfunction in one process won't affect others. This isolation is what makes Chrome's tabbed browsing powerful. - - Each tab runs as a separate process, ensuring issues in one tab don't disrupt others.

🧵 Thread:

A thread is a unit of execution within a process. Like chapters in a book, a process can have multiple threads (at least one, the main thread).
Threads within a process share the same memory address space. This means a failure in any thread affects the entire process execution.

🔁 Context Switch:

Imagine reading a book when someone interrupts you with a task. Before switching, you wisely place a bookmark on the page.This allows you to resume reading from the exact spot later.
Similarly, when one process/thread needs to execute while another is active, a context switch occurs. This involves saving the current state of the active process/thread and restoring the one needing execution, allowing it to pick up where it left off.
Context switching between processes is more expensive due to their distinct memory spaces. It involves updating page tables and other overhead.
In contrast, context switching between threads is much faster thanks to their shared memory space.

Threading

Threading is a python module which allows us to create a run threads
Threading gives an illusion of parallelism and not true parallelism due to Python's GIL(Global Interpreter Lock) even if we have multiple cores we can't achieve true parallelism

python's GIL : is a mutex(mutual-exclusion) lock which makes sure that only one thread of a process can execute at a given time

so under the hood a thread sheduler shedules the execution of threads (depending upon the os) by rapid context swicthing

due Global interpreter lock limitation threading is not a good candidate for cpu heavy task's, so where can we use threads ? we can use threading in I/O bound tasks( I/O operations like waiting for network requests or reading files); while a thread waits for I/O completion, other threads can be executed

Asyncio

Asyncio is a python module for asynchronous programming
Asyncio is same in the terms of functioning it also gives an illusion of parallelism but appoarch is different from threading

unlike threading where most of the things are handled by os, the event loop handles most scheduling and avoids explicit threading concerns in asynchronous programming. However, understanding coroutines and event loops can have a learning curve.

Asyncio Leverages an event loop and coroutines (special functions). The event loop manages tasks and schedules them for execution when resources become available (e.g., I/O completes). This minimizes context switching and avoids blocking the main thread. Coroutines: These are special functions that can be paused and resumed later. They are the building blocks of asynchronous code in asyncio. Event loops: These are responsible for managing the execution of coroutines and handling events. Asynchronous I/O: asyncio provides functions for performing I/O operations asynchronously, without blocking the main thread. async and await keywords: These keywords are used to define and use coroutines, respectively.

Multiprocessing

Multiprocessinh overcomes all of the problems that threadig has
Multiprocessing in Python allows you to create multiple processes that leverage multiple CPU cores, significantly improving performance for CPU-bound tasks
Processes communicate and share data using methods like pipes, queues, and shared memory
Remember to implement proper synchronization mechanisms like locks and semaphores to prevent race conditions when accessing shared resources

while technically we may achieve true parallelism with multiprocessing but we should consider some caveats

Global Interpreter Lock (GIL): The CPython implementation of Python has a Global Interpreter Lock (GIL) that restricts a single thread from executing Python bytecode at a time. This means even with multiple processes, only one thread within each process can truly execute Python code in parallel. While the processes themselves are separate, the Python execution within each process can still be serialized due to the GIL.

Overhead: Creating and managing processes involves overhead that can negate the benefits of parallelism for smaller tasks.

Angel Hack Community Builder's Programme 2024

Atul Kushwaha — Sat, 10 Feb 2024 22:00:00 +0000

Introduction:

Have you ever wondered if you could achieve something seemingly impossible, even before taking the first step? If so, then this article is for you! Hi there, I'm Atul Kushwaha, the GDSC Python Lead at my college and currently exploring the world of native Android development with Kotlin. Today, I want to share my experience of overcoming stage fright and landing a spot in the incredible AngelHack Community Builder Program.

Discovering the Program:

It all started with an email landing in my inbox, introducing the AngelHack Community Builder Program. The opportunity to create my own community, organize hackathons, and learn from industry experts instantly captivated me. However, there was one significant hurdle: applying required a video explaining my motivations and qualifications.

Facing My Fears:

As an introvert who had only recently begun overcoming stage fright, the video application was daunting. The thought of speaking in front of a camera triggered my anxiety, and I worried about being articulate and engaging enough. Remember, though, I was the GDSC Python Lead at my college! So, with some nervousness (but no self-doubt), I began crafting my video.

From Stumbles to Success:

Filming wasn't easy. Mispronunciations, filler words, and retakes plagued my initial attempts. But, fueled by my passion for community building, I persevered. After 40 takes, I had a video that felt genuine and represented my message authentically. I submitted it, and guess what? I got selected!

Learning and Growing:

Now, as a part of the program, I'm actively acquiring knowledge about community building, communication skills, and more. My key takeaway for fellow introverts? Don't let anxieties hold you back. Your first attempt may not be perfect, but every effort fuels your progress.

The Power of Authenticity:

You can watch my video here. While I may not have been perfectly fluent or brimming with confidence, my message and intentions shone through. Remember, authenticity trumps perfection. Your message matters more than how you deliver it. So, take that first step, share your genuine self, and watch your potential unfold!

Forem: Atul Kushwaha

hey guys i have been learning linear algebra from a great teacher and friend of mine, in such a way that i was able to see a linear transformation happening in my mind should i make a series of blogs on LA ?

Context Switch 🔁 in REAL life

Key Concepts

The Exam Analogy

Saving and Loading Context

Small Qt in Round Robbin

Parallel vs. Concurrent Execution

Free custom domain for your projects 😉

Step 1: Join the GitHub Student Developer Pack

Verify Your Student Status

Create or Log In to Your GitHub Account

Navigate to the GitHub Education Page

Start the Application Process

Complete the Application Form

Submit Your Application

Wait for Verification

Access Your Benefits

Renew Your Benefits (If Needed)

Tips for a Smooth Application

Step 2: Avail a Free Domain from Namecheap

Set Up the Domain in GitHub

Verify Domain Ownership with Namecheap

Add a CNAME Record (Optional)

Enable HTTPS

Conclusion

create and deploy projects seemleasly

Host Lovable.dev Project on github pages 😺

Host Lovable.dev Project on github pages 😺

Deploying a Lovable.dev Project to GitHub Pages

Here is the link to my portfolio, generated by lovable.dev and hosted on GitHub Pages

Prerequisites

Step 1: Connect lovable.dev with GitHub

Step 2: Create a New Repo for GitHub Pages and Update Config

Update vite.config.ts

Step 3: Push Code to GitHub and Set Up Workflow via GitHub Actions

Modify workflow.yaml as follows:

Step 4: Verify the Deployment

What is a Workflow?

Common Issues and Fixes

1. Blank Page After Deployment

2. 403 Permission Errors

3. Asset Paths Not Resolving

Conclusion

hey guys speed up your python code, especially with dynamic programming and recursive functions

Cache in Python !

Cache in Python !

Exploring Python's functools: Cache, Cached Property, and LRU Cache

1. cache: Simple, Unbounded Memoization

How It Works

Example

Why It’s Awesome

2. cached_property: One-Time Property Computation

How It Works

Example

Why It’s Awesome

3. lru_cache: Flexible, Bounded Memoization

How It Works

Example

Why It’s Awesome

Memory Handling in Java

primitives

Reference type

How primitives are stored ?

How Reference type stores value ?

Thread synchronization in python's threading module

Lock

RLock (Reentrant Lock):

Semaphore

BoundedSemaphore

conclusion

Race condition in Python's threading🏁

intuitive doubt

now, let's understand how race condition comes into picture even with GIL

Threading vs Asyncio vs Multiprocessing

Threading

Asyncio

Multiprocessing

Angel Hack Community Builder's Programme 2024

Introduction:

Update `vite.config.ts`

Modify `workflow.yaml` as follows:

Exploring Python's `functools`: Cache, Cached Property, and LRU Cache

1. `cache`: Simple, Unbounded Memoization

2. `cached_property`: One-Time Property Computation

3. `lru_cache`: Flexible, Bounded Memoization