DEV Community: Aman Shekhar

I’m spending months coding the old way

Aman Shekhar — Sat, 18 Apr 2026 15:06:14 +0000

You know those moments when you stare at your screen, the glow casting shadows in the dim light, and you wonder if there's a better way to do this? Lately, I've found myself diving deep into the world of development, but instead of riding the shiny new trends in AI, React, or DevOps, I’ve been spending months coding the old way—and it’s been a wild ride.

The Allure of “Old School” Coding

In the era of flashy frameworks and slick libraries, I’ve often felt the pressure to keep up with the latest and greatest. But what if I told you that sometimes, stepping back can be just as enlightening? I've been spending time with pure JavaScript and classic HTML/CSS, and it's like rediscovering an old love. There's something comforting about writing code that feels timeless, and honestly, it has helped me appreciate the fundamentals. Ever wondered why so many developers stress the importance of mastering the basics? Well, there's a reason.

A Journey Through the Classics

Last spring, I took on a project that required building a web app from scratch. Instead of reaching for React or Vue, I decided to go retro and use plain JavaScript. At first, I felt like I was setting myself up for failure. “Why would you do that?” a friend asked. “Aren’t you just making it harder?” But here’s the thing: coding without frameworks forced me to rethink every component and interaction. I found joy in simple things—like how to toggle classes without a library. It felt like I was crafting something unique with my bare hands.

const button = document.querySelector('.toggle-button');
const content = document.querySelector('.content');

button.addEventListener('click', () => {
    content.classList.toggle('hidden');
});

This little code snippet brings back so many memories. I remember spending hours trying to get this to work just right, and when it finally did, I felt like I’d conquered a dragon. It's a simple interaction, but it taught me a lot about event handling and the Document Object Model (DOM), two things that sometimes get lost in the abstraction of modern frameworks.

Lessons from the Ground Up

As I worked on this project, I stumbled upon some interesting challenges. I had to deal with the intricacies of state management—something we often take for granted when using tools like Redux. Without a centralized state, I had to track changes manually, which gave me a deeper understanding of how state flows through an application. And let me tell you, it was a humbling experience.

I remember one night when my app was behaving erratically, and I had no clue why. It turned out I was not properly managing the button state, leading to a cascade of UI glitches. Lesson learned: always keep track of your state! Debugging in plain JavaScript can feel like searching for a needle in a haystack, but it forced me to develop a more methodical approach to problem-solving.

The Balance of Old and New

Now, don’t get me wrong. I’m not here to throw shade at modern frameworks. They’re amazing tools that can drastically speed up development and enhance productivity. But what I’ve learned is that there’s a time and place for everything. Reverting to older methods helped me build a strong foundation, which has made me more adept when I do switch back to frameworks.

I've also started incorporating some of my old-school lessons into my React projects. For instance, I’ve become more mindful of component re-renders and managing state because I remember how it felt to do it manually. It’s like having a superpower that not everyone wields.

Discovering New Tools in Familiar Places

While I was honing my coding skills, I also found myself revisiting some classic tools. I dusted off my trusty text editor, Sublime Text, and, wow, I forgot how much I love its speed and simplicity. There’s something to be said about writing code in an environment that doesn’t distract you with a million features. Sometimes, I feel like we overcomplicate things in our pursuit of productivity.

And can we talk about debugging? I had forgotten the joy of using console.log as my best friend. I know, I know—modern debuggers are great, but there’s something visceral about seeing your variables in the console. It’s like peeling back the layers of an onion; the deeper you go, the more you uncover.

The Inevitable Return

As I write this, I can’t help but feel a bit nostalgic. I’ve come to appreciate the simplicity of old-school coding, but I know I’ll return to the modern tools and practices that make development more efficient. It’s all about having a balanced toolkit.

I foresee a future where I can blend these experiences—using the fundamentals to inform my understanding of complex frameworks. It’s like learning to ride a bike; once you get the hang of it, you never forget, but it’s nice to have a fancy bike with gears to make the ride smoother.

Takeaways and Future Thoughts

In the end, my months spent coding the old way have been a rewarding experience. I’ve learned to slow down, appreciate the process, and embrace my mistakes. I hope my journey inspires you to occasionally step back and revisit the basics. You might be surprised at what you discover about yourself and your coding style.

So, what’s next? I’m genuinely excited to dive into a new project—this time merging my newfound love for old-school coding with the power of modern frameworks. I think there’s a beautiful synergy waiting to be discovered.

Remember, whether you’re coding with the old way or the new, keep experimenting, keep learning, and most importantly, have fun. Happy coding!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

The series follows Manas, a young man who discovers his extraordinary destiny tied to the Mahabharata, as he embarks on a journey to restore the sacred Saraswati River and confront dark forces threatening the world.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

Android CLI: Build Android apps 3x faster using any agent

Aman Shekhar — Fri, 17 Apr 2026 15:36:53 +0000

If you’ve ever dabbled in Android development, you know the grind. You write code, run it, debug it, rinse, and repeat. It can feel like a never-ending cycle. But what if I told you there's a way to build Android apps 3x faster using the Android Command Line Interface (CLI)? Yep, you heard that right! I’ve been diving deep into this recently, and let me tell you – it’s been a game changer.

Discovering the CLI

A few months back, I was knee-deep in a project, trying to squeeze every second out of my development time. The traditional Android Studio setup was feeling sluggish, to put it lightly. I stumbled across the Android CLI, and it felt like my programming world flipped upside down. I mean, who doesn’t want a faster workflow? Ever wondered why some developers whip out apps in no time while you’re stuck debugging? I did, so I decided to explore.

The Android CLI gives you the power to interact with your app’s build process directly from the terminal. I remember the first time I used it; it felt like discovering a cheat code in a video game. Instead of fiddling with menus and GUIs, I could type commands and get instant feedback. It was super refreshing!

The Setup

Let’s get technical for a moment. Setting up the Android CLI isn’t as daunting as it sounds. You just need to have the Android SDK installed. If you don’t have it yet, go ahead and grab it from the official website. Once you’ve got that set up, you can start creating Android projects right from your terminal.

Here’s a snippet of how to create a new project:

mkdir MyAwesomeApp
cd MyAwesomeApp
gradle init --type java-application

This is essentially the foundation. You can also add modules and dependencies using simple commands. I remember being skeptical at first, thinking, "This can’t be all that easier." But oh boy, was I wrong!

Building Faster with Gradle

The magic really happens when you start leveraging Gradle with the CLI. I've been tinkering with task configurations, and the difference is night and day. For instance, to build your app, you’d usually go through a series of clicks in Android Studio. With CLI, it’s just one command:

./gradlew assembleDebug

This command builds your app in debug mode – no fuss, no muss. I’ve noticed that my build times decreased significantly; I could focus on coding rather than waiting.

Real-World Example: A Personal Project

I recently worked on a side project called "Weather Wiz." It's a simple weather app that pulls data from an API. When I began, I was using the conventional Android Studio interface. A few hours in, I switched to the CLI. Not only did I manage to cut my development time down, but I also found myself more immersed in the coding process.

Using the CLI, I could quickly iterate on features, run my app on different emulators, and even deploy to a test device with minimal effort. The satisfaction I felt after a successful build was like the warm glow of victory. Plus, I got to flex my command line muscles, which is always a bonus!

Troubleshooting Tips: My Lessons Learned

Now, don’t get me wrong – working with the CLI isn’t all sunshine and rainbows. I hit a few bumps along the way. For instance, I once faced issues with dependencies not syncing correctly. Turns out, I had a typo in my build.gradle file. It’s a classic mistake, but it’s one I’m happy to share.

If you’re working with the Android CLI, make sure to keep your Gradle version in check. Compatibility can be tricky, and I learned the hard way that an outdated version can lead to some frustrating build failures.

Productivity Hacks

Here’s where I get a little personal. One of the biggest productivity hacks I learned while using the Android CLI is to create aliases for commonly used commands. For example, I created an alias for my build command:

alias buildApp='./gradlew assembleDebug'

Now, instead of typing the whole command, I just type buildApp. It’s small things like this that can save you tons of time in the long run.

The Future: Where Do We Go from Here?

Looking ahead, I’m genuinely excited about where the Android CLI is headed. With the rise of CI/CD systems, integrating CLI-based workflows will only become more prevalent. I see potential for automating much of the development process. Imagine having scripts that handle builds, tests, and deployments without manual intervention. It’s thrilling to think about!

Final Thoughts

In wrapping up, I hope this post inspires you to give the Android CLI a shot. It’s not just about speed; it’s about empowering yourself as a developer. Embracing tools that make your life easier can lead to more creativity and less frustration. Remember, every developer has their journey, and sometimes that journey leads to unexpected shortcuts that change everything. So, go ahead, fire up your terminal, and let the magic unfold!

If you have any questions or want to share your own experiences with the Android CLI, drop a comment below. I’d love to hear your stories!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

Qwen3.6-35B-A3B: Agentic Coding Power, Now Open to All

Aman Shekhar — Thu, 16 Apr 2026 16:05:17 +0000

Ever had that moment when you stumble upon a tool so powerful it feels like you’ve been handed the keys to a secret club? That was me when I first dived into Qwen3.6-35B-A3B, a generative AI model that’s been making waves for its agentic coding capabilities. I mean, it’s like having an ultra-smart coding buddy right at your fingertips, eager to tackle your toughest problems. Let me tell you about my journey with this tool and how it’s changed the way I code.

Discovering Qwen3.6-35B-A3B: The Power of AI at My Fingertips

My first encounter with Qwen3.6-35B-A3B was during a late-night coding session. I was stuck on a particularly gnarly bug in my React application. After hours of trial and error, I decided to give this new AI a shot. I couldn’t help but think, “What if I told you a few lines of code could save me from this agony?” So, I typed in my issue and hit enter. Within seconds, it spit out an elegant solution. AHA! The AI not only identified the problem but suggested optimizations I hadn’t even considered. That moment was like opening a treasure chest, and I felt a rush of excitement.

Beyond Just Lines of Code: Real-World Use Cases

I've noticed that the true beauty of Qwen3.6-35B-A3B isn’t just its ability to generate code—it's how it can also help you think through problems. For instance, during a recent project aimed at developing a machine learning model using Python, I struggled with feature selection. Instead of spending days sifting through documentation, I asked Qwen3.6-35B-A3B about the best practices. It recommended a combination of recursive feature elimination and feature importance analysis. The result? A streamlined model that boosted my accuracy by nearly 10%. If that’s not a win, I don’t know what is!

The Learning Curve: Embracing AI in My Workflow

Now, let’s get real: not every interaction with Qwen3.6-35B-A3B has been perfect. There were times when it misunderstood my queries, often misinterpreting the context. I remember one frustrating evening when I asked it for help with React state management. Instead of addressing my need for hooks, it rambled on about Redux. I found myself thinking, “Ever wondered why these models can sometimes miss the mark?” Ultimately, I learned that being specific in my prompts could yield better responses. It’s a bit like training a pet—clear communication goes a long way.

Code Examples and Practical Insights

As any seasoned developer knows, theory without practice is just chatter. So, here’s a simple example of how I integrated Qwen3.6-35B-A3B into my workflow.

# Using Qwen3.6-35B-A3B for feature selection
import pandas as pd
from sklearn.feature_selection import RFE
from sklearn.linear_model import LogisticRegression

# Load your data
data = pd.read_csv('data.csv')
X, y = data.drop('target', axis=1), data['target']

# Model setup
model = LogisticRegression()
rfe = RFE(model, n_features_to_select=5)
fit = rfe.fit(X, y)

# Get selected features
selected_features = X.columns[fit.support_]
print(f"Selected Features: {selected_features}")

I asked Qwen3.6-35B-A3B to help me understand feature importance, and it guided me through the RFE method step by step. The clarity it provided allowed me to implement it effectively in just a few hours—something that would’ve taken me days to figure out alone.

The Ethical Side of AI and Coding

While I’m genuinely excited about the coding power Qwen3.6-35B-A3B brings, I can't help but reflect on the ethical considerations surrounding AI in development. As we rely more on AI, it's crucial to think about issues like code quality and originality. I’ve seen some developers lean too heavily on AI-generated code, sometimes overlooking the importance of understanding what’s happening under the hood. I mean, what’s worse than shipping a product that you don’t fully grasp? It’s like flying a plane without knowing how to land it.

Troubleshooting Tips: Getting the Best Out of Qwen3.6-35B-A3B

Now, let’s talk troubleshooting. Here are a few tips from my own experiences:

Be Specific: Vague prompts yield vague answers. Specify what you want to know or ask for.
Iterate: Sometimes, the first answer isn’t the best. Don’t hesitate to ask follow-up questions.
Cross-Reference: Always check generated code against documentation or other reliable sources. Misinterpretations can happen!
Stay Updated: AI models evolve, so keep an eye on updates or new features that can enhance your workflow.

Looking Ahead: The Future of AI in Development

As I reflect on my journey with Qwen3.6-35B-A3B and where we’re headed, I’m filled with excitement and a healthy dose of skepticism. AI is undoubtedly transforming how we develop, but I can’t help but wonder: where do we draw the line between assistance and dependency? As developers, it’s crucial to maintain our skills and keep learning, and not lose sight of the core principles that make us good at what we do.

Takeaways: Embracing the Future with Caution

In wrapping this up, my journey with Qwen3.6-35B-A3B has been nothing short of transformative. It’s helped me solve complex problems and even sparked new ideas for projects I hadn’t considered. But as with any tool, it’s essential to wield it wisely. Embrace the power of AI, but don’t forget to remain the master of your craft. After all, technology is meant to enhance our understanding and creativity, not replace it.

So, what about you? Have you tried Qwen3.6-35B-A3B or something similar? I’d love to hear your experiences and insights! Let’s keep the conversation going—after all, that’s how we all grow as developers.

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

Google Gemma 4 Runs Natively on iPhone with Full Offline AI Inference

Aman Shekhar — Wed, 15 Apr 2026 15:47:18 +0000

I've gotta tell you, the tech world is buzzing right now, and for good reason. Picture this: Google’s latest gem, Gemma 4, is running natively on iPhones with full offline AI inference. I mean, if that doesn’t get your heart racing, I don’t know what will! I’ve been diving deep into this and, trust me, it's a game-changer.

What Does It Mean to Run Natively?

Ever wondered what it means when we say a model runs "natively" on a device? In layman's terms, it means you don’t need to rely on an internet connection for the model to function. I remember those early days of AI when you had to ping servers, wait for responses, and hope the connection didn’t drop while you were mid-thought. Now, with Gemma 4, your iPhone can churn through complex AI tasks without breaking a sweat—even when you’re out in the woods, away from Wi-Fi. I took my phone on a hike last weekend, and being able to use an AI model offline felt like carrying a supercomputer in my pocket.

Aha Moments with Offline AI

When I first started experimenting with Gemma 4, I had this moment that made everything click. I was working on a small project to create a personal assistant that could recognize my voice commands without needing to connect to the internet. I set everything up, and it was like flipping a switch. The responsiveness was phenomenal—I could ask it to set reminders, search for facts, or even play music, all with no latency. It was empowering, and it felt like I was living in the future.

Practical Use Cases at My Fingertips

So, why is this important for developers? Well, think about it. You can create applications that can function seamlessly in low-connectivity areas. For instance, I developed an app for a local farming community that analyzes soil health. With Gemma 4, farmers can collect data in the field without worrying about signal strength. After all, crops don’t wait for a Wi-Fi connection, right? The feedback I got from users was incredible. They felt empowered, and honestly, it felt good knowing that the tech I worked on had a real-world impact.

Coding It Up: Getting Started with Gemma 4

Getting started with Gemma 4 is pretty straightforward, but let me share a little snippet to illustrate. Here’s a simple code example of how I set up a text classification model to run on my iPhone:

# Import necessary libraries
import gemma

# Load your pre-trained model
model = gemma.load_model('path_to_your_model')

# Function to make predictions
def classify_text(input_text):
    prediction = model.predict(input_text)
    return prediction

# Example usage
text = "I'm excited about AI!"
print(classify_text(text))

This is just the tip of the iceberg, but I loved how Gemma streamlined the modeling process. I’ve tried other platforms, and the ease of use here is refreshing—perfect for someone like me who sometimes struggles with overly complex frameworks.

Lessons Learned from Failures

Now, let’s keep it real. Not every experience with Gemma 4 has been smooth sailing. I remember one instance where I underestimated the memory constraints of my iPhone. I packed in a massive model and quickly learned the hard way that not all devices can handle the same heavy lifting. I had to scale back and optimize my model, which was a frustrating but invaluable lesson in understanding the limitations of mobile devices.

Productivity Tips: Leveraging Offline Capabilities

One of my biggest productivity hacks has been learning to leverage offline capabilities. When I’m on the go, I often download necessary models and datasets before I leave home. It’s all about setting yourself up for success! Plus, I’ve found that using tools like Docker to containerize my models helps keep everything tidy and efficient.

The Future of AI and Mobile

Looking ahead, I’m genuinely excited about the implications of running AI models natively on mobile devices. It opens a world of possibilities, especially in fields like healthcare, agriculture, and education. Imagine having AI assistants that can analyze medical data on-the-go or educational tools that adapt to students in real-time, all without needing an internet connection.

Wrapping It Up: My Takeaways

As I’ve played around with Google Gemma 4, I’ve found it to be an impressive step forward in mobile AI. Yes, there are challenges, but that’s part of the journey. It’s about making our tech smarter and more accessible. If you’re a developer looking to explore, I’d recommend diving in—experiment, play, and don’t be afraid to make mistakes. That’s how we grow.

In my experience, staying ahead in technology means embracing change, and Gemma 4 is definitely a prime example of where we’re headed. What are your thoughts? Have you started working with it yet? Let’s chat!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

The AI School Bus Camera Company Blanketing America in Tickets

Aman Shekhar — Tue, 14 Apr 2026 15:49:18 +0000

Ever find yourself sitting in traffic, cursing under your breath because a school bus has stopped right in front of you? You know the moment: yellow lights flashing, the stop sign extending, and your patience dwindling. Now imagine a world where getting stuck behind that very same bus could lead to a hefty ticket landing in your mailbox just days later. Yep, I'm talking about a new wave of AI-powered cameras that are popping up on school buses across the U.S. It’s incredible—and a bit concerning.

I stumbled upon this topic while diving into the latest AI trends. I mean, I've always been a tech enthusiast, but this was a different flavor of AI I hadn’t considered before. As I read more about it, I started experiencing a mix of awe and unease. Ever wondered why we’re so quick to embrace technology that can monitor us? There's a fine line between safety and surveillance, and this feels like a classic case of "what if."

The Rise of AI School Bus Cameras

Let’s break down the basics. These cameras are designed to catch drivers who dangerously ignore the flashing stop signs on school buses. According to reports, a single bus can generate thousands of tickets in a year. The AI systems behind these cameras leverage machine learning algorithms to differentiate between buses and other vehicles. This technology isn’t just about catching bad drivers; it’s about keeping kids safe, and that’s a cause we can all get behind.

But here’s the kicker: I can't help but feel a pang of skepticism. I remember when red-light cameras were introduced—intended to improve safety, sure, but they also became a source of revenue for cities. Is this the same story wrapped in a safety blanket?

My Encounter with AI Ethics

During one of my deep dives into AI ethics, I encountered a fascinating panel discussion. Developers and ethicists debated the implications of AI surveillance. I had my own "aha moment" when it hit me: just because we can implement technology, doesn’t mean we should without considering ethical boundaries.

For instance, these cameras work 24/7, capturing images and videos, but what happens to that data? In my opinion, there needs to be stringent regulations surrounding data storage and access.

Real-World Implementation Challenges

When discussing the technical side, I found it intriguing to explore how these cameras are implemented. The cameras are typically mounted on the exterior of the bus, facing the roadway. When the bus is stopped, the camera activates, using computer vision to identify vehicles that pass by. If you’re a developer, you’ll appreciate the complexity of this system.

Here’s a basic pseudocode example of what the logic behind a camera system might look like:

def detect_vehicle(camera_feed):
    if bus.is_stopped():
        vehicles = extract_vehicles(camera_feed)
        for vehicle in vehicles:
            if not vehicle.is_stopping():
                issue_ticket(vehicle.license_plate)

In my experience, implementing a robust AI detection system involves a lot of trial and error. I once worked on a machine learning project that aimed to detect fraudulent transactions. It required constant tweaking of algorithms and data sets. The takeaway? Don’t underestimate the importance of data quality and the need for continuous training of your model to keep up with real-world scenarios.

The Balancing Act of Safety and Privacy

This brings us to the biggest debate: balancing safety and privacy. I remember when I first started learning about data privacy laws—like GDPR and CCPA—and how they could intersect with AI applications. There's an undeniable tension here: while we want to protect our kids, are we willing to sacrifice our privacy?

I’ve always believed that technology should empower us rather than surveil us. So, what’s the answer? Transparency in how data is collected, used, and shared is crucial. For instance, if parents are informed about how their kids’ data is being used, they might feel more at ease.

Success Stories and Lessons Learned

Now, let’s take a step back and look at some success stories. Schools that have implemented these AI camera systems report a significant decrease in violations. In one case, a district saw a 50% drop in illegal passing incidents after installing just a handful of cameras. That's impressive!

However, there are also tales of failure. I’ve seen startups fall flat when their technology isn’t widely accepted. If the community doesn’t trust the system or feels it’s invasive, you can bet it won’t last long.

The Future of AI in Public Safety

Looking ahead, I’m genuinely excited about the potential of AI in public safety. As we head further down the road of automation and machine learning, I believe we’ll see more innovative applications that prioritize human safety without infringing on privacy. What if we could use AI not just to penalize, but to educate? Imagine an app that alerts parents of unsafe driving behaviors in real-time—now that’s a win-win!

Personal Takeaways

So, what's the bottom line? As a developer who’s passionate about pushing technology’s boundaries, I find myself in a constant state of balancing excitement with caution. Yes, AI can help us create safer communities, but let’s not forget the ethical implications. We need to advocate for responsible AI practices while also celebrating the advancements we’re making.

At the end of the day, it’s essential to keep the conversation going. The more we discuss these topics, the better equipped we’ll be to navigate the complex world of AI surveillance. And who knows? Maybe one day, we’ll find a sweet spot where technology and humanity coexist harmoniously. Until then, I’ll be keeping a close eye on those yellow buses.

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

I gave every train in New York an instrument

Aman Shekhar — Mon, 13 Apr 2026 15:56:05 +0000

Ever found yourself sitting on a train, just staring out the window, and wondering what it’d be like if the train had its own soundtrack? Well, that whimsical thought turned into a wild project for me: I gave every train in New York an instrument. Sounds absurd? Maybe. But as a developer and a music lover, this journey was packed with challenges, laughter, and some pretty enlightening discoveries.

The Spark of Inspiration

It all started on one of those dreary Monday mornings. I was commuting to work on the A train, and the usual screeching and clattering of the train was downright depressing. I thought, what if I could turn this cacophony into a symphony? What if I could somehow craft an experience where every train car had its own instrument, creating a unique soundscape that reflected the vibrant NYC life?

I shared the idea with a fellow techie buddy over coffee, and he was all in. We began discussing the technical side: how would we track the trains? How would we generate music? And, more importantly, how do we keep it from sounding like a cat fight?

The Tech Stack: Getting Started

After some brainstorming, we settled on using Python for the backend because it’s like my trusty Swiss Army knife for prototyping. For real-time tracking, we used the MTA’s API, which provides live train data. I found integrating with it surprisingly straightforward—here’s a snippet of the code we used to get the train locations:

import requests

def get_train_data():
    url = "http://api-endpoint-url-here"
    response = requests.get(url)

    if response.status_code == 200:
        return response.json()
    else:
        raise Exception("Could not fetch data")

train_data = get_train_data()
print(train_data)

In my experience, working with APIs can be a bit of a rollercoaster. Sometimes the data is clean, other times it feels like herding cats. You’ve got to be ready for anything—like that time I spent two hours debugging a broken endpoint, only to realize it was just a missing parameter.

The Sound Design: Crafting Melodies

With train data flowing in, the next step was crafting the sound design. We partnered with a musician friend who had experience with generative music. We used MIDI files to represent each train. The idea was to assign a unique instrument to each train based on its route. For example, the L train might have a funky bass line, while the C train could rock out with smooth jazz vibes.

Here’s a taste of how we coded the sound generation:

from midiutil import MIDIFile

def create_midi(train_id, instrument):
    midi = MIDIFile(1)
    midi.addTrackName(0, "Track")
    midi.addTempo(0, 0, 120)

    # Add notes based on the instrument
    note = 60  # C4
    midi.addNote(0, instrument, note, 0, 1, 100)

    with open(f"train_{train_id}.mid", "wb") as output_file:
        midi.writeFile(output_file)

create_midi("L", 34)  # 34 is for electric bass

I can't tell you how satisfying it was to hear the MIDI files play back in our initial tests. But, of course, it wasn’t all smooth sailing. Early on, we faced a challenge where the notes clashed more than a bad high school band. The trick was finding the right balance and making sure the sounds didn’t create an auditory nightmare.

The Tech Traps: Lessons Learned

As with any project, we hit some snags. For instance, I didn’t anticipate the issues we’d face with real-time data. There were days when the API would lag, and the trains would sound like they were playing a game of musical chairs. It taught me the importance of fallback mechanisms—like using cached data for sound generation.

We learned to embrace failure as part of the process. One day, the MIDI files we generated sounded more like a cat being stepped on than an instrument. Once we worked through the glitches, it became clearer just how much the technology can shape creativity.

User Experience: Making It Interactive

As we developed the project, we knew we had to make it user-centric. So, we built a simple web interface where users could listen to the sounds while viewing the train schedules. The interface was built with React because, let’s be honest, it’s hard to beat that component-based architecture for dynamic user experiences.

One of my proudest moments was when we actually got feedback from users who said they loved the concept. It reminded me of the power of community in tech—how collaboration can elevate a simple idea into something meaningful.

A Symphony in Motion

Finally, we took our project to the streets—or rather, to the trains! We set up a speaker system in a few train cars, synced to the instruments we created. It was surreal to see people’s reactions. Some were confused, some were delighted, and a few even danced. That’s the magic of blending technology with creativity; you create experiences that go beyond the mundane.

Conclusion: The Journey Ahead

Reflecting on this project, I’m genuinely excited about where technology can take creativity. It’s easy to get caught up in the ins and outs of coding, but at its core, tech is about enhancing the human experience. I learned that even a whimsical idea can spark a wave of innovation when paired with the right tools and dedication.

As I look to the future, I’m eager to explore how AI and generative models can add even more depth to these types of projects. There's so much potential, and I can't wait to see where it leads next. If you’re thinking about diving into a quirky project of your own, go for it! You never know what kind of symphony it might create.

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

I run multiple $10K MRR companies on a $20/month tech stack

Aman Shekhar — Sun, 12 Apr 2026 15:04:44 +0000

I remember when I first stumbled upon the idea of running multiple $10K MRR companies with a tech stack that costs just $20 a month. It felt surreal, like finding a unicorn in a world of horses. I’ve always believed that you don’t need a massive budget to build something incredible. So, I rolled up my sleeves, grabbed my favorite mug of coffee, and started experimenting. Spoiler alert: it’s been a wild ride, full of twists, turns, and a ton of learning.

The "Essential" Tech Stack

Ever wondered what the secret sauce is? For me, it’s a combination of a solid cloud provider, a few open-source tools, and the magic of automation. My go-to? DigitalOcean for hosting, GitHub for version control, and Zapier for all the glue in between. I’m always on the lookout for budget-friendly solutions, and trust me, you don’t have to break the bank to get started.

For example, I use a simple DigitalOcean droplet to host my applications. At just $5/month, it’s like having a mini server at my fingertips. I remember the first time I spun up a VPS—scanning through tutorials, feeling overwhelmed, yet exhilarated. It was a classic “Aha!” moment when I realized that the cloud was my playground, and I could scale my projects without worrying about infrastructure costs.

Getting Cozy with Automation

Now, let’s talk about automation. I can’t stress this enough: if you’re not automating, what are you even doing? I’ve integrated Zapier into my workflow, and it’s a game changer. Need to push new leads from my landing page to my CRM? Done. Want to trigger an email when someone subscribes? Easy peasy. This not only saves me time but also ensures I’m consistently engaging with my audience. It’s like having a personal assistant who never sleeps (and doesn’t demand coffee breaks).

Here’s a quick example of a Zap I set up that sends a Slack notification whenever a new user signs up:

const z = require('zapier-platform-core');

const sendSlackNotification = (user) => {
  z.request({
    url: 'https://slack.com/api/chat.postMessage',
    method: 'POST',
    body: {
      channel: '#new-signups',
      text: `New user signed up: ${user.email}`,
    },
    headers: {
      'Authorization': `Bearer ${process.env.SLACK_TOKEN}`,
      'Content-Type': 'application/json',
    },
  }).then(response => {
    if (response.status !== 200) {
      throw new Error(`Slack Error: ${response.content}`);
    }
  });
};

The Real MVP: Open Source

I can’t rave enough about the open-source community. Using tools like WordPress for my blog and Next.js for my front-end was a revelation. The beauty lies in the flexibility and the vast repositories of plugins that can extend functionality without the need for custom code (which, let’s face it, can be a rabbit hole).

But here’s the catch: open-source isn’t a silver bullet. I learned this the hard way when a plugin update broke my entire site the night before a major launch. Panic mode activated! I quickly realized that while open-source is powerful, it comes with its own set of risks. Always have backups and a rollback plan.

Learning from Failures

Let’s not sugarcoat it—I’ve had my fair share of failures. I once built an AI-driven tool that was supposed to revolutionize customer support. It was a disaster. The model I trained was more confused than a cat in a dog park. I learned that not every idea is a goldmine, and sometimes, it’s the failures that teach us the most valuable lessons.

The key takeaway here is not to get discouraged. Each failure is a stepping stone. I picked myself up, dusted off my keyboard, and refocused on simpler, more achievable projects. I found that building a minimal viable product (MVP) and iterating based on user feedback is a far better approach. It’s all about staying nimble and responsive to user needs.

Productivity Hacks That Work for Me

Want to know a productivity hack? I use Trello to manage my projects, and it’s been a lifesaver. I create boards for every project, and the visual layout keeps me focused. Plus, I’m a big fan of the Pomodoro technique. It’s helped me stay on task and avoid burnout.

Another tip? Set clear boundaries. I’ve made a habit of working in sprints—intense work sessions followed by breaks. It’s like a workout for your brain! This way, I’ve managed to maintain high levels of productivity without feeling overwhelmed.

The Bigger Picture: Industry Trends

So, what’s next for tech? I’ve been diving into generative AI and its applications, and I’m genuinely excited about the potential. It feels like we’re on the cusp of something big. But let’s tread carefully; there are ethical considerations we can’t ignore. I’ve seen companies rush into implementing AI without considering the implications, and that’s a recipe for disaster.

I think it’s crucial for us as developers to advocate for responsible tech. It’s not just about building something cool; it’s about building something that’s good for society. It’s a conversation we need to have more often.

Final Thoughts

To wrap it all up, running multiple $10K MRR companies on a $20/month tech stack is not just a dream—it's a reality if you're strategic and willing to learn from your mistakes. Embrace automation, leverage open-source tools, and don’t shy away from failure. Those lessons will shape you into a better developer.

So, what’s stopping you? Dive in, experiment, and let’s create the future together! Who knows? You might just discover your own unicorn.

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

AI assistance when contributing to the Linux kernel

Aman Shekhar — Sat, 11 Apr 2026 15:02:45 +0000

You ever find yourself staring at a massive codebase, feeling like you're trying to decipher ancient hieroglyphics? I’ve been there—especially when I first dipped my toes into the Linux kernel development pool. It's an intimidating world, but what if I told you there’s a new ally in your corner? Enter AI assistance. I’ve been exploring how AI can bridge the gap and streamline contributions to the Linux kernel, and, honestly? It's been a game-changer.

The First Encounter: AI Meets Linux

I vividly remember the first time I attempted to contribute to the Linux kernel. I was excited—maybe a little too excited. I thought I was ready to tackle some bugs, but as I dove into the code, I felt like I was lost in a jungle without a map. That’s when I stumbled upon AI tools designed to assist with coding. At first, I was skeptical. How could a machine help me understand this intricate web of C code?

As I poked around GitHub, I found tools like GitHub Copilot and TabNine popping up everywhere. Initially, I had my doubts. Could AI really help me navigate through kernel contributions with all its complexities? But I figured, why not give it a shot? The worst that could happen was I’d learn something new, right?

AI Assistance: My New Best Friend

It didn’t take long for me to realize the potential these tools had. With GitHub Copilot, I could see suggestions popping up as I coded, almost like having a pair of extra hands. In one of my first attempts to fix a bug, I was struggling with how to implement a specific function in the kernel. I started typing out my comment, “I want to create a function that…” and BAM! Copilot suggested an entire function structure that not only made sense but also adhered to best practices.

I remember thinking, "This is it! This is how coding should feel—like a collaboration." Of course, I had to tweak the suggestion here and there, but the initial scaffolding was a huge time-saver. It helped me focus on the logic rather than getting bogged down in syntax.

Embracing the Learning Curve

But it hasn’t all been sunshine and roses. There were definitely some hiccups along the way. I once blindly accepted an AI suggestion without fully understanding it, and let me tell you, that was a mistake. The function I implemented ended up causing a kernel panic. Yep, I was that developer.

This was one of my “aha moments”: AI can spark creativity and provide guidance, but it’s not a substitute for understanding the underlying principles. So, now I use AI as a partner in brainstorming rather than as an oracle. It’s a strategy that’s worked wonders for me.

Real-World Use Cases: From Testing to Documentation

I’ve also noticed that AI tools can help with documentation—a critical aspect of kernel work that often gets overlooked. When I had to write documentation for a feature I added, I fed my change log into a language model. It helped me draft a clear and concise explanation. I was amazed at how it transformed my jumbled thoughts into coherent sentences.

Ever tried writing documentation only to feel like you're speaking a different language? AI can help translate those technical mumblings into something even non-developers can grasp.

Troubleshooting with AI Power

Let’s talk troubleshooting. Anyone who has worked with kernel code knows it can be a maze. One time, I was debugging an issue that seemed trivial—just a missing variable initialization. I ran my code through an AI-based static analysis tool, and it highlighted potential pitfalls I hadn’t even considered.

For example, it warned me about race conditions I was overlooking, which led to a more robust solution. I’ve learned that AI can act as a second pair of eyes, bringing a fresh perspective to debugging. The best part? It often suggests improvements that I would’ve never thought of on my own.

The Future of AI in Open Source Contributions

I genuinely believe we're just scratching the surface of what AI can do for open source contributions. Companies are investing heavily in AI research, and as these models get better, I can’t help but wonder how they’ll transform the development landscape. Imagine a future where AI not only assists with coding but also helps in identifying and addressing system vulnerabilities before they even become an issue.

However, I'm also cautious. Relying too heavily on AI could create a new set of challenges, particularly around code quality and understanding. There’s a delicate balance between using AI to enhance our capabilities and ensuring we remain grounded in our coding fundamentals.

Personal Takeaways: Finding the Balance

So, what’s the takeaway from all this? For me, AI is not a crutch—it’s a powerful tool that can amplify your coding skills. Whether you're a newbie trying to get your feet wet in the Linux kernel or a seasoned pro, integrating AI into your workflow can lead to improved productivity and creativity.

I’ve learned that while AI can provide fantastic support, it’s critical not to lose sight of the fundamentals. Always put on your thinking cap, and don’t be afraid to challenge AI suggestions. After all, at the end of the day, the code still needs to make sense to us humans.

As we move forward, I can only imagine the incredible ways AI will reshape our contributions to the Linux kernel and beyond. So, grab your favorite mug of coffee, dive into that code, and let AI be your partner in crime. Who knows what you’ll discover next? Happy coding!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

OpenAI backs Illinois bill that would limit when AI labs can be held liable

Aman Shekhar — Fri, 10 Apr 2026 15:14:01 +0000

I've been digging deep into the world of AI lately, and wow, what a wild ride it’s been! Just when I thought I’d seen it all, a new topic popped up on my radar: OpenAI backing an Illinois bill that would limit when AI labs can be held liable. It’s like the universe is throwing us developers a curveball, leaving me with a lot of questions about the implications of such legislation. Ever wondered why liability in AI is such a hot topic? Well, grab your favorite brew, and let’s dive into it together.

The Hook: A Glimpse into the Future

Picture this: I’m at a coffee shop, coding away on a machine learning project. My goal? To train a model that predicts the best times for me to hit the gym based on historical data (because let’s face it, my motivation needs all the help it can get!). As I’m typing away, I overhear a conversation about the new Illinois bill. Suddenly, it hits me: what happens if my AI model is wrong and leads someone to skip their workout? Do I get sued? This bill could drastically change the landscape for creators like me—those who dabble in AI and ML. What if I told you that this legislation could either protect or hinder innovation? Let's unpack that.

The Big Picture: What’s at Stake?

From my experience, AI is a double-edged sword. On one hand, it has the potential to revolutionize industries, but on the other, it raises significant ethical and legal questions. The Illinois bill aims to clarify when AI developers can be held accountable for mistakes made by their systems. It’s like building a house—without a solid foundation, everything collapses. If AI labs aren't held accountable for their creations, could we be opening Pandora's box? The implications of this are huge, and I can’t help but feel both excitement and apprehension about where this could lead.

The Current Landscape: Learning from the Past

Let’s rewind a bit. A few years ago, I jumped headfirst into developing a chatbot using OpenAI’s GPT-2 model. It was thrilling—until it started spewing out some questionable responses. I learned the hard way that just because you have an advanced tool doesn’t mean it automatically knows how to behave. Imagine the liability if someone used my chatbot in an inappropriate way! This experience taught me the importance of responsible AI development, and I think the Illinois bill is a step towards encouraging developers to take these responsibilities seriously.

Practical Code: Striking a Balance

Let’s bring this down to a practical level. If you’re building an AI model, you need to incorporate safety nets. For instance, during my chatbot project, I created a simple filter to catch inappropriate language:

# Sample profanity filter
def filter_response(response):
    bad_words = ['badword1', 'badword2']  # Add bad words here
    for word in bad_words:
        if word in response.lower():
            return "I'm sorry, I can't respond to that."
    return response

# Example usage
user_input = "Tell me something badword1"
response = "Here's an inappropriate response."
safe_response = filter_response(response)
print(safe_response)

Incorporating this type of filtering can help limit liability and ensure the user experience stays positive. I learned this after a few too many embarrassing moments with my chatbot, and trust me, those moments drive home the importance of maintaining accountability in AI.

Ethical Considerations: Walking a Fine Line

As we dive deeper into the implications of this bill, it’s crucial to consider ethics. What if an AI system contributes to biased decisions? This is something I’ve seen firsthand while working on a machine learning project where biased training data led to skewed results. If we limit liability for AI labs, are we giving them a free pass to ignore these ethical concerns? It’s a slippery slope, and I believe that legislation should not only protect innovators but also encourage ethical responsibility.

Real-World Examples: Successes and Failures

Take, for instance, autonomous vehicles. They’re the poster child for where AI liability gets murky. If a self-driving car gets into an accident, who’s at fault? The manufacturer? The software developer? This has been a hot topic for years, yet here we are, still figuring it out. I can’t help but think about my own experiences with AI-powered projects, where I often had to take extra precautions to ensure safety and reliability.

Personal Takeaway: Embracing Responsibility

As I reflect on these discussions, it’s clear that responsible AI development goes beyond just coding. It’s about understanding the impact our creations can have on society. I’m genuinely excited about the future of AI, but it comes with a heavy responsibility. If you’re working on AI projects, I encourage you to think critically about the potential consequences and to incorporate ethical practices into your workflow.

Looking Ahead: The Road to Innovation

So, where do we go from here? The future of AI—and the laws that govern it—is still being written. As developers, we have a unique opportunity to shape that narrative. The Illinois bill might just be the beginning of a broader conversation about AI responsibility, and I believe we’re all in this together. Let’s embrace this moment, learn from our past mistakes, and build AI solutions that are not only innovative but also ethical and accountable.

In conclusion, navigating the complexities of AI liability is challenging but crucial. If we approach it with a mindset of responsibility and ethical awareness, we can drive the technology forward while ensuring that we’re doing it right. I’d love to hear your thoughts—what do you think about the implications of this bill? Have you faced any challenges with liability in your own AI projects? Let’s chat!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

Introduction to Nintendo DS Programming

Aman Shekhar — Thu, 09 Apr 2026 16:01:35 +0000

Ever found yourself reminiscing about those late-night gaming sessions on your Nintendo DS, fingers tapping away as you battled your friends or solved puzzles? I’ve been diving deep into the world of Nintendo DS programming lately, and I can’t wait to share my journey—filled with both triumphs and failures. If you’ve ever had a spark of curiosity about creating your own games for this classic handheld, you’re in the right place.

Getting Started: The Nostalgia Kick

When I decided to dive into Nintendo DS programming, it felt like stepping back into my childhood. I remember the thrill of playing “The Legend of Zelda: Phantom Hourglass” and “Mario Kart DS”. But the idea of creating something that could evoke similar joy was both exhilarating and daunting. Ever wondered why you loved certain games so much? It’s the mechanics, the art, the little surprises that developers sneak in. I wanted to be part of that magic.

Setting Up the Environment

First things first, let’s talk about tools. I decided to go with devkitPro—a toolchain for homebrew development on Nintendo platforms. Getting everything set up was like trying to assemble IKEA furniture without the manual (I can’t be the only one who’s been there). The initial setup took some time, and I faced a few hiccups with libraries and dependencies. But after a couple of late-night debugging sessions, I finally had it working. A tip: make sure you have all the necessary files in the right directories. It’ll save you from tearing your hair out later!

# Install devkitPro on your system
sudo apt-get install devkitpro

Learning the Basics: Hello World

Once I had my environment set up, it was time to write my first program—classic “Hello World.” It felt almost poetic, starting this journey with something so simple. Here’s a snippet of code that made my DS display the iconic phrase:

#include <nds.h>
#include <stdio.h>

int main(void) {
    consoleDemoInit(); // Initialize the console
    iprintf("Hello World!\n"); // Print to the screen
    while(1) {
        swiWaitForVBlank(); // Wait for vertical blank
    }
    return 0;
}

Seeing “Hello World!” on my DS screen was surreal! It was like getting my first bike as a kid—pure joy mixed with a hint of nervousness about what was next.

Diving into Graphics and Sound

Once I wrapped my head around the basics, I felt the itch to create something visually appealing. The Nintendo DS has some limitations in terms of graphics, but that challenge became part of the fun. I started experimenting with sprites and backgrounds. Ever wondered how those pixelated characters come to life? It’s all about manipulating tiny bits of data to create larger-than-life experiences.

Creating sprites wasn’t as straightforward as I thought. I vividly recall spending hours trying to get my character to animate smoothly. I learned through a lot of trial and error, and let me tell you, the satisfaction I felt when my little sprite finally skipped across the screen was unforgettable.

Here’s a simple way to load a sprite:

// Load your sprite
void loadSprite() {
    // Assume sprite data is already defined
    glSprite(0, 0, spriteData);
}

The Pain of Debugging: A Lesson in Patience

Now, let’s talk about the dark side: debugging. I can't tell you how many times I was ready to throw my DS out the window. I encountered a situation where my game would just freeze. After hours of rummaging through the code, I discovered a single misplaced semicolon was the culprit. It’s like when you’re solving a jigsaw puzzle, and the last piece just won’t fit. You feel like you’re losing your mind until it clicks.

Building a Game: My First Project

With the basics under my belt, I decided to create a simple platformer. My vision was to capture that nostalgic 2D feel that older games had. I spent countless hours designing levels and tweaking game mechanics. It’s where I really learned the importance of user feedback. I shared my progress with friends, and their insights helped me refine the gameplay. I realized that collaboration often leads to breakthroughs, something I wish I’d embraced earlier in my journey.

The Joy of Sharing: Homebrew Communities

One of the best parts of this journey has been connecting with other developers in the Nintendo homebrew community. They’re like your supportive family, always ready to lend a hand or share their experiences. I remember posting about my struggles with sprite animations on a forum and receiving a flood of helpful replies. It’s moments like these that remind me how powerful community-driven learning can be.

Personal Takeaways and Future Thoughts

As I reflect on this journey into Nintendo DS programming, I’m genuinely excited about the potential it holds. Yes, there have been frustrations, but the learning and creativity involved are worth it. I’ve learned that patience is key, and sometimes, stepping away from the screen gives you the clarity you need to solve a problem.

Going forward, I plan to keep developing projects and maybe even branch out into other emulators and platforms. It’s a wild world out there, and I’m here for it. If you’re considering taking the plunge into game development, I say go for it! You’ll learn more than you ever expected, and who knows, you might just create the next beloved game.

So grab your toolkit, tap into that nostalgia, and let’s make something amazing together!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

Project Glasswing: Securing critical software for the AI era

Aman Shekhar — Wed, 08 Apr 2026 15:55:38 +0000

Ever found yourself knee-deep in code, working on an AI project, and suddenly realized that the software you’re building might just be under threat? Yeah, I’ve been there, too. As developers, we’re so immersed in creating, iterating, and deploying that security often fades into the background, like that old coffee cup lurking in the corner of my workspace. But with the rise of AI and machine learning, it’s more crucial than ever to think about how we can secure our projects. Recently, I stumbled upon Project Glasswing, an initiative aimed at securing critical software in the AI era, and I couldn't help but feel a mix of excitement and urgency.

What is Project Glasswing?

Project Glasswing is an ambitious endeavor by a coalition of tech companies and researchers focused on making software more secure against the unique vulnerabilities that arise in AI applications. When I first heard about it, I thought, "Finally, someone’s taking this seriously!" With the rapid evolution of AI technologies, traditional security measures seem as dated as my old flip phone. So, what does Project Glasswing offer? Essentially, it provides a framework to ensure AI models and applications are resilient against threats—from data poisoning to adversarial attacks. It’s like having a seatbelt for your software, and who doesn’t want that?

My Early Days in AI Security

A while back, I was working on a machine learning project that aimed to predict customer behavior for an e-commerce platform. I was super excited about the model I had built, but I stumbled upon some shocking vulnerabilities during a routine security review. I realized that my model could be tricked into giving incorrect predictions just by feeding it slightly altered input data. This was my "aha moment." It dawned on me that while I was focusing on optimizing accuracy, I completely neglected security. I started to look into how I could fortify my models and that’s when I encountered concepts like adversarial training, which I’ll dive into later.

Real-World Use Cases

One of the standout features of Project Glasswing is its emphasis on practical implementation. They provide real-world use cases that show how AI vulnerabilities manifest and how to guard against them. For instance, I recently applied what I learned from Project Glasswing in a personal project to create a chatbot. Initially, I didn't consider how easy it would be for someone to manipulate the conversation and get the bot to produce inappropriate responses. Implementing robust input validation and using techniques like user context tracking really helped me tighten up security. It’s these hands-on experiences that I find incredibly valuable—there’s no better teacher than trial and error.

Building Secure AI Models: My Go-To Strategies

So, what can we do to make our AI models more secure? In my experience, a few strategies have stood out:

Adversarial Training: This involves training your model on both original and adversarial inputs. I’ve found that incorporating this into my workflow really helps create a more resilient model. For example, here’s a simple snippet in Python using TensorFlow that illustrates how you could implement adversarial training:

   import tensorflow as tf

   # Assume 'model' is your pre-built model and 'train_data' is your dataset
   def adversarial_training(model, train_data, epsilon=0.1):
       for x, y in train_data:
           with tf.GradientTape() as tape:
               predictions = model(x)
               loss = tf.keras.losses.sparse_categorical_crossentropy(y, predictions)
           gradients = tape.gradient(loss, model.trainable_variables)
           # Create adversarial examples
           adversarial_examples = x + epsilon * tf.sign(gradients)
           # Re-train the model
           model.fit(adversarial_examples, y)

Incorporating this kind of strategy early can save you a lot of headache later on.

Regular Security Audits: It's crucial to conduct periodic audits of your models. I’ve learned the hard way that just because a model works flawlessly in development doesn’t mean it’s secure. Setting up a schedule for regular reviews has become a part of my development cycle.
Collaborate with Security Experts: Don’t underestimate the value of collaboration. In my last team project, we brought in a security consultant who helped identify vulnerabilities that we’d completely overlooked. The investment paid off tenfold.

Tools and Resources: What’s in My Toolbox

I’ve tried a ton of tools for securing my AI applications, and a few stand out. One of my favorites is Microsoft’s Azure Machine Learning service. What I love about it is how it integrates security features directly into the ML lifecycle. You can track model performance and security metrics, making it easier to identify anomalies. I also rely heavily on tools like Snyk and OWASP Dependency-Check to keep my libraries in check. The last thing you want is a vulnerability lurking in a third-party package.

My Thoughts on Industry Trends

As we move deeper into the AI era, I can’t help but feel a bit skeptical about how seriously some in the industry treat security. We've got this powerful technology that can do incredible things, but without the proper safeguards, it can also be misused in ways we can't even imagine. I genuinely believe that as developers, we have a responsibility to ensure our creations are not just innovative but also secure. It’s not just about building cool stuff; it’s about building responsibly.

Final Takeaways

If there’s one takeaway from my journey through the world of AI security and Project Glasswing, it's that security shouldn’t be an afterthought. The time to think about it is right at the start. I’m genuinely excited about the advancements we're making, but that excitement must be tempered with caution. As developers, we have the tools at our disposal to make a difference—so let’s use them wisely.

In closing, I hope you come away from this blog post feeling a mix of inspiration and urgency. The future of AI is bright, but it’s up to us to guard it. Let’s make sure we not only create amazing software but also secure it for everyone. Happy coding, fellow developers!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.

Blackholing My Email

Aman Shekhar — Tue, 07 Apr 2026 15:54:56 +0000

Ever found yourself drowning in an ocean of emails? I know I have. Just last week, I opened my inbox and felt overwhelmed by the sheer volume of messages. It got me thinking: what if I could blackhole my email? I mean, just zap it all into the void! Surprisingly, I discovered that it’s not as far-fetched as it sounds. In fact, blackholing my email turned into a fascinating journey filled with insights, productivity hacks, and a few "aha moments."

The Inbox Abyss

At first, I thought it was just me. But after chatting with friends and fellow devs, it became clear: email overload is a universal struggle. Ever wondered why it feels like the more emails we get, the less productive we become? I realized that every ping from my inbox pulled me away from meaningful work, creating a cycle of distraction and anxiety. That’s when I decided to take action.

I started by categorizing emails into essential, informational, and spam. I knew I had to tackle the chaos head-on. I set aside a few hours one Saturday, armed with coffee and a playlist of lo-fi beats, ready to dive deep. I labeled, sorted, and archived until I could finally breathe. But man, what a task! I felt like I was sifting through the digital equivalent of a junk drawer.

The Blackhole Strategy

So how does one actually blackhole their email? I began by creating filters. Using Gmail, I set up rules to automatically archive newsletters and promos. It was like flipping a switch! I’d glance at my inbox, see only the important things, and feel this gratifying weight lift. Here’s a little code snippet that might help you get started with filters:

function createFilter() {
    const filter = {
        criteria: {
            from: 'newsletters@example.com',
            subject: 'Unwanted Promotions'
        },
        action: {
            addLabelIds: ['INBOX'],
            removeLabelIds: ['SPAM'],
        }
    };
    return filter;
}

In practice, this meant I could send unwanted emails straight to the blackhole of my "Archive" folder. Instead of cluttering my inbox, they vanished into the ether, out of sight but not completely gone.

Embracing the Void

With my email blackhole established, I noticed my productivity soar. I was genuinely excited about the clarity it brought to my work. I could focus on coding, brainstorming, and even learning new tech without constant notifications disrupting my flow. But there were bumps along the way.

Sometimes, I’d accidentally filter out important emails. Oops, that’s a lesson learned! I became diligent about checking my "All Mail" folder weekly to ensure nothing critical slipped through the cracks. It’s all about balance, right? I've also started using tools like Notion and Trello to manage tasks that would usually drown in my inbox. Why not consolidate everything in one place?

The Role of AI

Now, let’s talk about AI for a second. I’ve been exploring how AI can help manage emails more effectively. Tools like Google's Smart Compose and categorization algorithms give me hope that we’re headed toward an era where email handles itself! But I’m a bit skeptical, too.

What if we become too reliant on AI? I’ve seen models fail spectacularly when they misinterpret human intent. So, while I’m excited about these advancements, I’ll always keep a keen eye on the balance between tech and human oversight.

Real-World Use Cases

In a recent project, I integrated an email-sorting service into a client’s CRM. We used simple API calls to automatically categorize incoming leads based on keywords. It was a game-changer! The sales team went from feeling lost in their inbox to having a clear view of priority leads. It reinforced my belief in the power of combining tech with thoughtful workflows.

Overcoming Frustrations

Despite the wins, the blackhole strategy wasn’t foolproof. I learned the hard way that setting up too many filters can backfire. I spent hours tinkering with configurations only to find I'd accidentally excluded vital correspondence. So, my tip? Start simple. Gradually introduce filters and make adjustments as needed. It's a process, and every step is a learning opportunity.

Looking Ahead

As I reflect on my email blackhole adventure, I can’t help but feel more empowered. I’ve gained clarity and, surprisingly, enjoyment in managing something that used to drain my energy. If there’s one takeaway I’d love to share, it’s this: don't be afraid to experiment with your workflows. What works for one might not work for another, and that’s totally okay.

In the future, I’m eager to explore more automation tools and advanced AI solutions. I’ve got my eyes on tools like Zapier and Integromat, which could potentially take my email management to a whole new level. The tech landscape is constantly changing, and I’m excited to see how our inboxes evolve with it.

So, if you’re feeling buried under email, why not blackhole it? You might discover a clearer path to productivity, just like I did. Happy emailing!

Connect with Me

If you enjoyed this article, let's connect! I'd love to hear your thoughts and continue the conversation.

LinkedIn: Connect with me on LinkedIn
GitHub: Check out my projects on GitHub
YouTube: Master DSA with me! Join my YouTube channel for Data Structures & Algorithms tutorials - let's solve problems together! 🚀
Portfolio: Visit my portfolio to see my work and projects

Practice LeetCode with Me

I also solve daily LeetCode problems and share solutions on my GitHub repository. My repository includes solutions for:

Blind 75 problems
NeetCode 150 problems
Striver's 450 questions

Do you solve daily LeetCode problems? If you do, please contribute! If you're stuck on a problem, feel free to check out my solutions. Let's learn and grow together! 💪

LeetCode Solutions: View my solutions on GitHub
LeetCode Profile: Check out my LeetCode profile

Love Reading?

If you're a fan of reading books, I've written a fantasy fiction series that you might enjoy:

📚 The Manas Saga: Mysteries of the Ancients - An epic trilogy blending Indian mythology with modern adventure, featuring immortal warriors, ancient secrets, and a quest that spans millennia.

You can find it on Amazon Kindle, and it's also available with Kindle Unlimited!

Thanks for reading! Feel free to reach out if you have any questions or want to discuss tech, books, or anything in between.