Software projects rarely stay small. Features grow, requirements change, and teams expand. When data access logic is tightly coupled with business logic, even a simple update can break multiple parts of the system. This is where the Repository Pattern becomes extremely valuable. In this blog, we’ll explain the Repository Pattern in a clear and beginner-friendly...
If you’ve ever used Hilt in a Jetpack Compose app, you’ve probably written code like this: Kotlinclass MyRepository @Inject constructor( @ApplicationContext private val context: Context ) And then paused for a second and thought: “Okay… but where is this @ApplicationContext coming from?” “Who creates it?” “And how does Hilt magically inject it at runtime?” This article answers...
Navigating through code efficiently is crucial for productive Android development. Android Studio provides powerful back and forward navigation features that help you jump between different code locations, making it easier to trace code flow, review changes, and return to previous working contexts. In this comprehensive guide, we’ll explore everything you need to know about implementing...
Android background execution is one of the most misunderstood parts of the platform, especially when alarms, notifications, and device reboot come into play. Most tutorials show what code to write. Very few explain why that code works, what Android is doing internally, or why certain architectural rules are non-negotiable. This article fills that gap. We’ll...
If you’ve ever opened GitHub and noticed the wrong name on your commits — or spotted a commit on your main branch that never should’ve been there. These are some of the most common (and stressful) Git problems developers run into, especially when working in teams or switching between multiple accounts.
The good news is this: Git gives you the tools to fix both issues cleanly. The bad news? Using the wrong command can make things worse if you don’t understand what’s really going on.
This guide walks you through:
Everything here is based on how Git actually works under the hood — not IDE myths.
Let’s clear up the most common misunderstanding first:
Android Studio does not control your Git commit author. Git does.
Android Studio is just a client. When you click “Commit,” it asks Git two questions:
Git answers based on its configuration files. That’s it.
So changing your GitHub account inside Android Studio affects authentication (push and pull permissions), but it does not change the commit author. That’s why this issue keeps coming back.
Git identifies authors using two values:
user.nameuser.emailThese can exist at two levels:
Git always prefers local settings over global ones.
If you work on multiple projects or use more than one GitHub account, this is the safest approach.
Open your project, then click Terminal at the bottom.
git config user.name "Your Correct Name"<br>git config user.email "[email protected]"git config user.name<br>git config user.emailFrom this point forward, all new commits in this project will use the correct author.
If every repository on your machine is using the wrong user, update the global config:
git config --global user.name "Your Name"<br>git config --global user.email "[email protected]"Verify with:
git config --global --listaThis affects all Git repositories on your system.
Android Studio’s GitHub settings only control:
They do not control commit authorship. That’s why you can push to one account while commits show another name entirely.
If you’re using SSH, GitHub identifies you by your SSH key, not your username.
Check which account your machine is using:
ssh -T [email protected]If GitHub responds with the wrong username, your SSH key is attached to the wrong account.
~/.ssh/config to explicitly use that keyThis ensures commits and permissions align correctly.
Changing Git config only affects future commits.
Once a commit exists:
That’s intentional. Git values integrity over convenience.
If the most recent commit has the wrong author:
git commit --amend --author="Your Name <[email protected]>"<br>git push --force-with-leaseOnly do this if rewriting history is acceptable.
Use interactive rebase:
git rebase -i HEAD~NChange pick to edit for the commits you want to fix, then run:
git commit --amend --author="Your Name <[email protected]>"<br>git rebase --continueFinish with:
git push --force-with-leaseThis is where many developers panic. The right solution depends on who else is affected.
Use this only if:
git log --oneline<br>git reset --hard <last-good-commit><br>git push origin <branch> --force-with-leaseEveryone else must reset their local branch afterward.
If the branch is shared or protected, always revert.
git revert <bad-commit-hash><br>git push origin <branch>This creates a new commit that undoes the change without rewriting history.
| Situation | Recommended |
|---|---|
| Secrets pushed | Reset + force push |
| Mistake on main | Revert |
| Cleaning your feature branch | Reset |
| Team already pulled | Revert |
For mixed good and bad commits:
git rebase -i HEAD~5Change pick to drop for unwanted commits, then:
git push --force-with-leaseAlways create a backup branch first:
git branch backup-before-cleanup
--force instead of --force-with-leaseIf something goes wrong, git reflog can usually save you.
Android Studio often gets blamed for Git problems it doesn’t actually control. Once you understand that Git owns identity and history, everything becomes easier to reason about — and fix.
By setting the correct Git user, managing SSH keys properly, and choosing the right strategy for removing commits, you can keep your repositories clean without disrupting your team.
If you treat Git history with intention instead of panic, it becomes a powerful tool instead of a constant source of stress.
If Android Studio refuses to start and throws an error like:
Internal error<br>com.intellij.platform.ide.bootstrap.DirectoryLock$CannotActivateException: Process "studio64.exe" is still running and does not respond.…you’re dealing with one of the most common (and confusing) Android Studio startup issues.
It usually appears after a crash, a forced shutdown, or reopening the IDE too quickly. The good news is that this error does not mean your installation is broken. It’s a safety mechanism that fails to recover properly in real-world conditions.
This guide explains what’s actually happening under the hood, why it shows up more often on Windows, how it behaves on macOS and Linux, and how to fix — and prevent — it permanently.
Android Studio is built on the JetBrains IntelliJ Platform, which enforces a single-instance lock.
When Android Studio starts, it does three important things:
When you close Android Studio normally, all of that is cleaned up.
But if the IDE:
those locks don’t always get released.
When you try to reopen Android Studio, it checks for those locks, assumes another instance is still running, and blocks startup to protect your data.
That’s when you see errors like:
DirectoryLock$CannotActivateExceptionProcess is still running and does not respondAddress already in useConnection refusedThis behavior is intentional — but the recovery is imperfect.
No.
This error is cross-platform and occurs on Windows, macOS, and Linux.
That said, Windows developers see it far more often, and there are clear technical reasons for that.
1. Fast Startup (Hybrid Shutdown) — Windows Fast Startup doesn’t fully terminate background processes. If Android Studio was open during shutdown, its locks may survive the reboot.
2. Aggressive File Locking — Windows uses mandatory file locks. If the IDE freezes or crashes, those locks are more likely to be left behind.
3. Antivirus & Defender Interference — Real-time scanners can delay or block the IDE’s socket binding, triggering false “already running” states.
4. Zombie Java Processes — If studio64.exe or its Java runtime crashes, Windows may leave it running invisibly in the background.
Result:
Windows users encounter this error far more frequently than macOS or Linux users.
macOS handles process cleanup more gracefully, which reduces the frequency — but doesn’t eliminate it.
Common macOS triggers include:
Because macOS is Unix-based, socket cleanup is usually reliable, but stale lock files can still remain after abnormal exits.
Linux is the least affected platform.
When the error appears, it’s usually caused by:
kill -9.config or .cacheLinux aggressively cleans up sockets and file locks, which is why this issue is relatively rare there.
| Operating System | Likelihood | Overall Stability |
|---|---|---|
| Windows | High | Most problematic |
| macOS | Medium | Mostly stable |
| Linux | Low | Most reliable |
Windows
studio64.exe or java.exemacOS
Linux
pkill -f android-studioIf the error shows a PID, target that process directly.
Sometimes the process is gone, but the lock file remains.
Windows
C:\Users\<User>\AppData\Local\Google\AndroidStudio<version>/macOS
~/Library/Caches/Google/AndroidStudio<version>/Linux
~/.cache/Google/AndroidStudio<version>/Delete files such as:
port.lock.lock*.lock filesThen restart Android Studio.
If you see BindException or Address already in use, the fastest fix is a full system reboot.
This clears all sockets and zombie processes instantly.
This behavior isn’t unique to Android Studio.
All JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm) use the same architecture. The IDE prioritizes data safety over convenience:
The problem isn’t the design — it’s that real machines crash, sleep, and lose power.
This error is not your fault, and it’s not a sign of a broken setup.
It happens because of:
Once you understand what’s going on, fixing it takes minutes — and preventing it becomes easy.
If you work with Android Studio long enough, you’ll see this error at least once. Now you know exactly what to do when it happens.
GitHub Gists are great for sharing small pieces of code, configuration files, or quick notes. They’re fast, lightweight, and easy to link.
But many developers hit the same question sooner or later:
How do we add images to GitHub Gists?
If you’ve tried uploading an image directly or embedding one like you would on GitHub README files, you’ve probably noticed it’s not straightforward.
In this guide, we’ll walk through adding Images to GitHub Gists in detail. You’ll learn what works, what doesn’t, and why GitHub behaves the way it does. We’ll also cover reliable methods with clear examples you can use right away.
GitHub Gists look similar to repositories, but they’re not the same thing.
A few key differences matter here:
Because of this, adding Images to GitHub Gists require a different approach.
Short answer: No.
GitHub Gists do not support direct image uploads the way repositories do.
You can:
But you cannot:
That’s not a bug. It’s a design choice.
Even though you can’t upload images directly, you can display images in a Gist using external image hosting.
The idea is simple:
Let’s go through the working methods.
This is the best and most stable way to add Images to GitHub Gists.
Create a repository or use an existing one, then upload your image:
my-repo/
└── images/
└── img1.pngOnce uploaded, click the image and copy the raw URL.
It will look like this:
https://raw.githubusercontent.com/username/repo/main/images/img1.pngUse standard Markdown syntax inside your Gist:
! tells Markdown this is an imageExample Image1 is the alt text (important for accessibility and SEO)This method works consistently and is trusted by GitHub.
This method is popular but less controlled.
The URL will look like this:
https://user-images.githubusercontent.com/12345678/img2.pngPros
Cons
For short-lived examples, this approach works. For professional use, prefer repositories.
You can also use services like:
Important Notes
This method works, but reliability depends on the host.
Understanding what doesn’t work is just as important.
This will not work in Gists:
Why?
Because Gists don’t have a file system like repositories.
<img> Tags with Local FilesThis also fails:
<img src="image.png" />The browser has no idea where image.png lives.
You can drag images into GitHub issues, but not into Gists.
If you try, nothing happens.
GitHub Gists are meant to be:
Allowing image uploads would:
That’s why adding Images to GitHub Gists rely on external hosting.
To keep your Gists clean and professional, follow these tips:
Instead of:
Use:
This improves:
Large images slow down loading and distract from the code.
Ask yourself:
If yes, include it. If not, skip it.
If your image changes over time:
This avoids broken references in old Gists.
Adding Images to GitHub Gists isn’t hard once you understand the rules.
You can’t upload images directly, but you can embed them reliably using external URLs. GitHub repositories are the safest option, while issue uploads and external hosts work in specific cases.
Use images sparingly, explain them clearly, and your Gists will be far more useful than plain code alone.
If you’ve built Android apps with Jetpack Compose, you’ve probably run into the question: Should I use ViewModel or rememberSaveable? Both help you keep state alive, but they work very differently depending on what’s happening to your app — like when the screen rotates or when the system kills your process. This post will break down ViewModel...
If you’ve ever worked with collections in Kotlin or Java, you’ve probably heard about Kotlin Sequences and Java Streams. Both are powerful tools for handling large amounts of data in a clean, functional style. But when should you use one over the other? And what’s the real difference between them?
This guide breaks it all down in simple way — no jargon overload. By the end, you’ll know exactly when to reach for Kotlin Sequences or Java Streams in your projects.
Collections like List and Set are everywhere. But looping through them with for or while can quickly become messy, especially when you want to:
This is where lazy evaluation comes in. Instead of processing all elements up front, sequences and streams let you chain operations in a pipeline. The work only happens when you actually need the result. That means cleaner code and often better performance.
Kotlin’s Sequence is basically a wrapper around collections that delays execution until the final result is requested.
fun main() {
val numbers = listOf(1, 2, 3, 4, 5)
val result = numbers.asSequence()
.filter { it % 2 == 1 } // Keep odd numbers
.map { it * it } // Square them
.toList() // Trigger evaluation
println(result) // [1, 9, 25]
}Here,
.asSequence() converts the list into a sequence.filter and map are chained, but nothing actually runs yet..toList() triggers evaluation, so all steps run in a pipeline.Key takeaway: Sequences process elements one by one, not stage by stage. That makes them memory-efficient for large datasets.
Java introduced Stream in Java 8, giving developers a way to work with collections functionally.
import java.util.*;
import java.util.stream.*;
public class StreamExample {
public static void main(String[] args) {
List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
List<Integer> result = numbers.stream()
.filter(n -> n % 2 == 1) // Keep odd numbers
.map(n -> n * n) // Square them
.toList(); // Collect into a list
System.out.println(result); // [1, 9, 25]
}
}.stream() converts the collection into a stream.filter and map are chained..toList() (or .collect(Collectors.toList()) in older Java versions) triggers evaluation.Streams are also lazy, just like Kotlin Sequences. But they come with a big advantage: parallel processing.
Here’s a side-by-side comparison of Kotlin Sequences or Java Streams:
Example: processing thousands of lines from a text file efficiently.
Example: data crunching across millions of records using parallelStream().
If you’re in Kotlin, stick with Kotlin Sequences. They integrate beautifully with the language and make your code feel natural.
If you’re in Java or need parallel execution, Java Streams are the way to go.
And remember: it’s not about one being “better” than the other — it’s about choosing the right tool for your context.
When it comes to Kotlin Sequences or Java Streams, the choice boils down to your project’s ecosystem and performance needs. Both give you lazy, functional pipelines that make code cleaner and more maintainable.
Now you know when to use each one, and you’ve seen them in action with real examples. So the next time you need to process collections, you won’t just write a loop — you’ll reach for the right tool and make your code shine.
Artificial Neural Networks (ANNs) are one of the driving forces behind today’s AI revolution. From recognizing faces in photos to powering voice assistants, they’re everywhere. But what exactly are they? And how do they mimic the human brain? Let’s break it down step by step.
Artificial Neural Networks are computational models inspired by how the human brain processes information. Just like our brains use billions of interconnected neurons to learn and make decisions, ANNs use layers of artificial “neurons” to detect patterns, classify data, and make predictions.
At their core, ANNs are about finding relationships in data. Whether it’s images, text, or numbers, they can spot patterns we might miss.
The inspiration for ANNs comes directly from biology:
Think of it like this:
Every ANN is built from layers:
Each connection between neurons has a weight, and learning means updating those weights to improve accuracy.
Training an ANN is like teaching a child. You show it examples, it makes guesses, and you correct it until it improves. Here’s the typical process:
Let’s build a tiny ANN to classify numbers using TensorFlow and Keras. Don’t worry — it’s simpler than it looks.
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense
# Step 1: Build the model
model = Sequential([
Dense(16, input_shape=(10,), activation='relu'), # hidden layer with 16 neurons
Dense(8, activation='relu'), # another hidden layer
Dense(1, activation='sigmoid') # output layer (binary classification)
])
# Step 2: Compile the model
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
# Step 3: Train the model with dummy data
import numpy as np
X = np.random.rand(100, 10) # 100 samples, 10 features each
y = np.random.randint(2, size=100) # 100 labels (0 or 1)
model.fit(X, y, epochs=10, batch_size=8)relu helps capture complex patterns; sigmoid squashes outputs between 0 and 1, making it great for yes/no predictions.adam): Decides how the network updates its weights.binary_crossentropy): Measures how far off predictions are from actual results.fit): This is where learning happens—weights get adjusted to reduce errors.Artificial Neural Networks power much of modern AI, including:
Their strength lies in adaptability: once trained, they can generalize knowledge and apply it to new, unseen data.
While powerful, ANNs have challenges:
Researchers are working on making them more efficient and interpretable.
Artificial Neural Networks are one of the best examples of how humans have borrowed ideas from nature — specifically the brain — to solve complex problems. They’re not truly “intelligent” in the human sense, but their ability to learn from data is transforming industries.
As we move forward, ANNs will continue to evolve, becoming more powerful and more transparent. Understanding the basics today means you’ll be ready for the AI-powered world of tomorrow.