DEV Community: Manoj sai Challagulla

ViewModel LifeCycle Over Navigations

Manoj sai Challagulla — Tue, 23 Jun 2026 07:18:01 +0000

When is a ViewModel Created?

Suppose you have:

class ProfileViewModel : ViewModel()

and inside your screen:

@Composable
fun ProfileScreen(
    viewModel: ProfileViewModel = viewModel()
) {

}

The ViewModel is not created when the app starts.

It is created when the screen first requests it.

User opens Profile Screen
          ↓
viewModel() called
          ↓
Android checks:
"Do I already have a ProfileViewModel?"
          ↓
No
          ↓
Create ProfileViewModel

What happens during recomposition?

Suppose state changes:

Text(name)

changes from:

Manoj

to:

Manoj Sai

Compose recomposes.

Many beginners think:

Screen recomposed
↓
ViewModel recreated

❌ Wrong.

The same ViewModel instance is reused.

Screen Recompose #1
      ↓
Same ViewModel

Screen Recompose #2
      ↓
Same ViewModel

Screen Recompose #100
      ↓
Same ViewModel

This is why ViewModels survive recompositions.

What happens during screen rotation?

Imagine:

Portrait
↓
Rotate
↓
Landscape

Activity gets recreated.


Without ViewModel:

plaintext
Data lost

With ViewModel:

Activity destroyed
↓
New Activity created
↓
Same ViewModel reused

That's one of the biggest reasons ViewModels exist.

## When is ViewModel Destroyed?

The ViewModel lives as long as its owner lives.

For example:

plaintext
Profile Screen opened
↓
ViewModel created
↓
User stays on screen
↓
ViewModel alive

Then:

plaintext
User presses Back
↓
Profile screen removed
↓
ViewModel no longer needed
↓
onCleared()
↓
ViewModel destroyed


## What is onCleared()?

Before Android destroys the ViewModel it calls:

kotlin
override fun onCleared() {
super.onCleared()
}


Think of it as:

plaintext
"Hey ViewModel,
I'm about to destroy you.
Clean up anything you're using."


At this moment:

kotlin
viewModelScope.cancel()


is automatically triggered.

Real Example with Navigation

Suppose:

plaintext
HomeScreen
↓
ProfileScreen

User opens Profile:

ProfileScreen created
↓
ProfileViewModel created


User stays there:

plaintext
ProfileViewModel alive

User returns to Home:

plaintext
ProfileScreen removed from back stack
↓
ProfileViewModel.onCleared()
↓
ProfileViewModel destroyed


## Navigation Compose Case

Suppose:

plaintext
Home
↓
Profile
↓
Settings

plaintext

Current back stack:

Home
Profile
Settings

plaintext

When you're on Settings:

ProfileViewModel

plaintext

may still be alive because Profile is still in the navigation back stack.

Only when Profile is removed from the back stack:

Home
Settings

plaintext

then:

ProfileViewModel destroyed
Complete Lifecycle


User opens screen
        ↓
Android creates ViewModel
        ↓
ViewModelScope created
        ↓
Coroutines launched
        ↓
Screen recomposes many times
        ↓
Same ViewModel reused
        ↓
User leaves screen permanently
        ↓
onCleared()
        ↓
viewModelScope cancelled
        ↓
All coroutines cancelled
        ↓
ViewModel destroyed

This is why we say:

A ViewModel survives recompositions and configuration changes (like rotation), but it is destroyed when its owner is permanently removed and Android calls onCleared().

ViewModel VS Coroutine Scope

Manoj sai Challagulla — Tue, 23 Jun 2026 07:05:01 +0000

1. Coroutine

A coroutine is the actual background task.

Example:

launch {
    api.getProfile()
}

Here, the work is:

api.getProfile()

So coroutine means:

A lightweight task that can run without blocking the main thread.

2. CoroutineScope

A CoroutineScope is like a container/manager for coroutines.

It decides:

Where coroutine runs
How long coroutine lives
When coroutine should be cancelled

Example:

val scope = CoroutineScope(Dispatchers.IO)

scope.launch {
    // coroutine work
}

Here:

scope = manager
launch block = coroutine

3. viewModelScope

viewModelScope is a special CoroutineScope given by Android to every ViewModel.

Example:

class ProfileViewModel : ViewModel() {

    fun loadProfile() {
        viewModelScope.launch {
            repository.getProfile()
        }
    }
}

Meaning:

Run this coroutine inside the ViewModel’s scope.

4. Relationship

Very important:

CoroutineScope is the general concept.

viewModelScope is one specific CoroutineScope.

Coroutine is the actual task running inside the scope.

Like this:

ViewModel
   owns
viewModelScope
   manages
coroutines

Visual:

ProfileViewModel │ └── viewModelScope │ ├── coroutine 1 → API call ├── coroutine 2 → DB operation └── coroutine 3 → file operation

5. Why use viewModelScope?

Because it automatically cancels coroutines when ViewModel is cleared.

viewModelScope.launch {
    delay(10000)
    println("Done")
}

If user leaves the screen before 10 seconds:

Screen closed
↓
ViewModel cleared
↓
viewModelScope cancelled
↓
Coroutine cancelled

So "Done" will not print.

6. Without viewModelScope

val scope = CoroutineScope(Dispatchers.IO)

scope.launch {
    delay(10000)
    println("Done")
}

Here you created the scope manually.

So you must cancel it manually:

scope.cancel()

Otherwise it may continue even after the screen is gone.

7. Final Note

Write this in your notes:

Coroutine = actual background task.

CoroutineScope = manager/container that controls coroutines.

viewModelScope = Android-provided CoroutineScope attached to ViewModel.

When ViewModel is cleared, viewModelScope is automatically cancelled.

So all coroutines launched inside viewModelScope are also cancelled.

Best simple line:

viewModelScope.launch { } means:

Run this coroutine as long as the ViewModel is alive.

WINDOWS USERS CRUD

Manoj sai Challagulla — Mon, 22 Jun 2026 18:26:41 +0000

READ

whoami

→ Who am I currently logged in as?

net user

→ Show all users.

net user <username>

→ Show details of a user.

net localgroup Administrators

→ Show all admins.

CREATE

net user <username> <password> /add

→ Create a user.

net localgroup Administrators <username> /add

→ Make a user an admin.

UPDATE

net user <username> <new_password>

→ Change password.

net user <username> /active:no

→ Disable a user.

net user <username> /active:yes

→ Enable a user.

net localgroup Administrators <username> /delete

→ Remove admin rights.

DELETE

net user <username> /delete

→ Delete a user.

The 8 commands I'd memorize
whoami

net user

net user <username>

net localgroup Administrators

net user <username> <password> /add

net localgroup Administrators <username> /add

net localgroup Administrators <username> /delete

net user <username> /delete

USERS AND GROUPS IN WINDOWS

Manoj sai Challagulla — Mon, 22 Jun 2026 18:01:12 +0000

First Principle

A User and a Group are different things.

Think of a college.

Students

Manoj Rahul Priya

These are people.

Groups

Students
Faculty
Principal

These are roles.

A person can belong to one or more groups.

Example:

Manoj
└── Students

Principal
└── Faculty
└── Management

Windows works exactly the same way.

Windows Internal Structure

When you create:


manoj

Windows only creates an identity.

At this point Windows knows:

User Name = manoj
SID = S-1-5-21-xxxx...

SID = Security Identifier.

Internally Windows doesn't really care about the name.

It identifies users by SID.

Why Groups Exist

Imagine Windows had 1000 users.

Without groups Microsoft would have to store permissions separately for every user.

Example:

Manoj -> Can install software
Rahul -> Can install software
Priya -> Can install software
John -> Can install software

That's inefficient.

Instead:

Administrators
    ├── Manoj
    ├── Rahul
    ├── Priya
    └── John

Now Windows says:

Anyone inside Administrators
gets these permissions.

Much easier.

Common Windows Groups

Run:

net localgroup

You'll see many groups.

The important ones are:

Administrators

Most powerful group.

Members can:

✅ Install software

✅ Create users

✅ Delete users

✅ Access all files

✅ Change passwords

✅ Install drivers

✅ Change system settings

Example:

Administrators
├── Administrator
└── thriv

Users

Default group.

Almost everyone belongs here.

Can:

✅ Use apps

✅ Browse internet

✅ Save files

Cannot:

❌ Create users

❌ Install drivers

❌ Change system security

Guests

Temporary users.

Very limited access.

Example:

Someone borrows your laptop.

You don't want them accessing your files.

Create Guest account.

Remote Desktop Users

Can log into the computer remotely.

Example:

Remote Desktop Users
└── Manoj

Now Manoj can connect using Remote Desktop.

What Happens During Login?

Suppose:

User = manoj

Windows checks:

Which groups does manoj belong to?

Maybe:

manoj
├── Users
└── Administrators

Windows loads permissions from both groups.

Result:

manoj gets admin rights
Permission Calculation

Suppose:

Administrators

has:

Install Software
Delete Users
Change Settings

And:

Users

has:

Run Programs
Save Files

If Manoj belongs to both:

manoj
├── Users
└── Administrators

Then Manoj gets:

Run Programs
Save Files
Install Software
Delete Users
Change Settings

Windows combines permissions.

Real Example From Your Laptop

Earlier:

net localgroup Administrators

showed:

Administrator
thriv

Meaning:

thriv
└── Administrators

Therefore:

thriv can:
- create users
- delete users
- install software

But:

manoj

was not in that group.

So:

manoj
└── Users

Only normal permissions.

Adding User to Group

This command:

net localgroup Administrators manoj /add

does NOT create a new user.

It simply changes:

Before:

manoj
└── Users

After:

manoj
├── Users
└── Administrators

Now Manoj becomes admin.

Removing User From Group

This command:

net localgroup Administrators manoj /delete

changes:

Before:

manoj
├── Users
└── Administrators

After:

manoj
└── Users

Admin powers gone.

Important Concept: UAC (User Account Control)

You might have noticed:

Even when you're an Administrator, Windows still asks:

Do you want to allow this app to make changes?

Why?

Because Windows doesn't want malware to get full admin power automatically.

So even Admin users run with limited rights initially.

When you click:

Run as Administrator

Windows temporarily gives full admin privileges.

Linux Comparison (Useful for Backend Engineers)

Since you're learning Django and servers:

Windows:

User
↓
Group
↓
Permissions

Linux:

User
↓
Group
↓
Permissions

Exactly the same concept.

Example:

sudo

in Linux is very similar to:

Run as Administrator

in Windows.

Troubleshooting Git Authentication: Fixing "Repository Not Found" on Private Repositories

Manoj sai Challagulla — Mon, 22 Jun 2026 02:57:19 +0000

When working with private Git repositories, running into a fatal: repository '...' not found error is incredibly common. It’s a frustrating roadblock, especially when you know the repository exists and that you have access to it in your web browser.

This article walks through why this error happens and exactly how to fix it by clearing outdated credentials in Windows.

The Misconception: user.email vs. Authentication

A common trap many developers fall into is assuming that configuring their global Git identity acts as a login key:

Bash

git config --global user.name "Your Name"
git config --global user.email "your.email@example.com"

The Reality

These commands only sign your work. They act like a handwritten signature at the bottom of a letter—anyone can write any email address they want there.

git config settings are strictly used to stamp a name and profile picture onto commits.

Authentication (cloning, pushing, pulling) relies entirely on separate cryptographic keys or Personal Access Tokens (PATs) managed by your operating system.

When you attempt to clone a private repository and your local machine passes a stale, invalid token, GitHub won't say "Access Denied." For security reasons, it completely masks the repository and returns a Repository not found error so unauthorized users cannot verify a private project's existence.

Step-by-Step Resolution

If you can see the repository perfectly fine in Google Chrome but your terminal throws a not found error, follow these steps to reset your connection.

Step 1: Clear Caching in Windows Credential Manager

Windows caches your Git authentication tokens using a tool called Credential Manager. If your token expires or changes, Windows keeps trying to use the old one anyway.

Press the Windows Key, type Credential Manager, and hit Enter.
Click on Windows Credentials on the right side.
Scroll down to the Generic Credentials section.
Locate the entry named git:https://github.com.
Click the small down arrow (˅) to expand it and click Remove or Delete.

Step 2: Trigger a Fresh Clone

With the broken, cached token completely erased, head back to your terminal and execute your clone command again:

Bash
git clone https://github.com/username/repository-name.git

Step 3: Authorize via Browser OAuth

Because your saved credentials were deleted, Git Credential Manager will instantly prompt an automated browser popup to securely verify your identity.

Click Sign in with your browser on the popup.

Authorize the application on GitHub's secure page.

Note on a common quirk: Once authorized, your browser might display a This site can’t be reached or 127.0.0.1 refused to connect error. You can safely ignore this!

This happens because the temporary background authentication server closed the exact millisecond your token was successfully transferred to your terminal. Check your command line, and you will see the files downloading flawlessly:

Plaintext

Cloning into 'repository'...
info: please complete authentication in your browser...
remote: Enumerating objects: 4913, done.
remote: Counting objects: 100% (306/306), done.
Updating files: 100% (405/405), done.

Conclusion
Next time Git insists a private repository doesn't exist, skip editing your config file and head straight to the Windows Credential Manager. Wiping out the stale git:https://github.com entry forces a clean handshake, getting you back to coding in less than a minute.