Forem: Aman Shekhar

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.

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.

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.

Show HN: I built a tiny LLM to demystify how language models work

Aman Shekhar — Mon, 06 Apr 2026 15:12:05 +0000

Ever found yourself staring at a complex language model, feeling a mix of awe and confusion? I know I have! A few months back, I decided to dig into the world of LLMs (Large Language Models) and learn how they work from the ground up. Spoiler alert: it wasn’t all rainbows and sunshine, but it was one heck of a journey! I’ve always been curious about how these models generate human-like text, and it felt time to demystify the black box that is AI.

The Spark of an Idea

It all started with a simple question: “What if I could build my own tiny LLM?” I wanted to create something that could help others understand these models without the overwhelming complexity. So, I set off on a quest to build a miniature language model, which eventually became my pet project. My goal? To make it accessible, relatable, and downright fun!

I’ll admit, I had my fair share of hiccups along the way. From library conflicts to hours spent debugging, I learned that programming is a lot like life—full of unexpected surprises. But with each obstacle, I grew more determined. Ever experienced that moment when everything clicks? That was my “aha” moment, and it felt incredible.

Building Blocks of Understanding

Let’s get down to brass tacks. To build my tiny LLM, I turned to Python and a few libraries I was already familiar with, like NumPy and Hugging Face’s Transformers. If you’re into AI, you know how powerful these libraries can be! Here’s a snippet of the code I started with to create a basic tokenizer:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")
sentence = "Hello, world!"
tokens = tokenizer.encode(sentence)
print(tokens)  # Outputs the token ids

In my experience, understanding tokenization was a game-changer. It’s like learning the ABCs before diving into writing essays. Without it, you’re just lost in a jungle of words.

Training the Tiny Giant

Now came the fun part—training the model! I decided to use a small dataset that I curated from various sources, focusing on conversational text to give it that human-like touch. I started with a few hundred lines, and boy, did I underestimate how demanding the training process could be.

At first, my model was about as useful as a wet blanket. It generated sentences that were all over the place, and I couldn't help but laugh at some of the ridiculous outputs. Ever wondered why some AI-generated text sounds like it’s trying too hard? That was my model in its early days!

But I learned quickly. I iterated through various hyperparameters, experimenting with batch sizes and learning rates until I found the sweet spot. It was a classic case of trial and error. My advice? Don’t shy away from failure. Embrace it—it’s where the real learning happens.

Real-World Applications and Use Cases

Once my tiny LLM started producing coherent sentences, I felt like a proud parent! I quickly started exploring real-world applications. Could it help with chatbots? Absolutely! It could even assist in generating creative writing prompts. I remember feeling that electric buzz of excitement when I typed in a prompt and got back something surprisingly relevant.

Consider using LLMs for educational tools. For instance, I created a simple web app using React where users could input a question, and my model would respond with an answer. It was like having a mini tutor at your fingertips. Here’s a peek into how I set up the API with Flask:

from flask import Flask, request, jsonify
app = Flask(__name__)

@app.route('/generate', methods=['POST'])
def generate_text():
    input_text = request.json['input']
    # Here, add your model's generate function
    response_text = model.generate(input_text)
    return jsonify({"response": response_text})

if __name__ == '__main__':
    app.run(debug=True)

The Ethical Conversation

As I delved deeper into the world of LLMs, I couldn’t ignore the ethical implications. I mean, we’ve all read about the potential for misuse, right? It led me to ponder: What are the responsibilities we hold as developers? I believe it’s crucial to implement safeguards and ensure our models are trained responsibly.

I’ve seen firsthand how easily misinformation can spread. It’s a double-edged sword when you think about it. We have the power to educate and inform, but with that power comes the responsibility to be ethical. So, if you’re working on your own LLM, keep this in mind. It’s not just about creating something cool; it’s about considering its impact on society.

Debugging Life Lessons

Believe me, debugging a language model is not for the faint-hearted. I’ve encountered perplexing errors that left me scratching my head, only to realize I’d forgotten to preprocess my input data correctly. It was a classic case of overlooking the basics.

One thing I recommend is to keep a detailed log of your experiments. I’ve found that documenting what worked and what didn’t not only helps with troubleshooting but also serves as a valuable learning resource for future projects. It’s like having a personal mentor guiding you through the coding wilderness.

Looking Ahead: The Future of Tiny LLMs

Reflecting on my journey with my tiny LLM, I can’t help but feel excited about the future of AI and machine learning. I see incredible potential for these models in various fields—education, content creation, and even mental health support. The possibilities are practically endless!

As I wrap up this post, I want to encourage you, fellow developers, to dive into this fascinating world. Whether you’re building your own LLM or simply exploring existing models, take the leap! You never know what you might discover about yourself and the technology shaping our future.

In conclusion, I’m genuinely excited about the journey of creating my tiny LLM. I’ve learned so much, faced challenges head-on, and come out the other side with a deeper understanding of the technology. So, what’s stopping you? Let’s demystify language models 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.

Someone at BrowserStack Is Leaking Users' Email Address

Aman Shekhar — Sun, 05 Apr 2026 15:01:42 +0000

I’ll be honest: when I first heard that someone at BrowserStack was leaking users’ email addresses, I had that gut-wrenching feeling you get when you realize your favorite hoodie is missing. You know? That sinking feeling that you’ve lost something precious, and in this case, it’s a shred of trust in a tool I’ve relied on for years.

To give you a bit of background, I’ve been using BrowserStack for quite a while now. It’s been my go-to for cross-browser testing. I remember the first time I set up my project on it; I was struggling to ensure my React app looked consistent across all browsers. I stumbled across BrowserStack, and it felt like I’d been handed a magic wand. Suddenly, I could see how my app rendered on various devices. It was truly an "aha moment" for me. But now, with this news, I can’t help but feel a twinge of skepticism.

What Happened?

The news broke when users started reporting that they were receiving emails meant for others. Imagine being bombarded with someone else's account info or, worse, sensitive data. It's like receiving a stranger's mail—only it’s digital and way more concerning. BrowserStack has since addressed the issue, apologizing and stating they’re investigating. However, that doesn't wash away the feeling of unease. Ever wondered why such a big name in the tech industry would let something like this slip?

The Importance of Trust in Tech

Let’s be real. In this age where data breaches make headlines almost daily, trust is paramount. I've often said that the strength of a tool is only as good as the trust you place in it. When you’re working on client projects, it’s not just your data; it’s their lives, their businesses. I remember a project I worked on for a small startup. They had entrusted me with sensitive user data while I was integrating their app with various platforms. I made sure that every line of code was secure because their trust was on the line. So, when I heard about the BrowserStack leak, I couldn't help but reflect on how fleeting that trust can be.

Lessons Learned: Data Security Practices

From my own experiences, this situation serves as a stark reminder of how crucial data security practices are. I’ve learned the hard way—like the time I left a database connection string exposed in a GitHub repository. Oops! Thankfully, I caught it in time, but the panic was real. So, what can developers take away from this? First off, always validate and sanitize user inputs. This is something I implement religiously now. Here’s a quick code snippet to illustrate how I handle data validation in a Node.js app:

const express = require('express');
const app = express();

app.use(express.json());

app.post('/user', (req, res) => {
  const { email } = req.body;
  // Simple validation
  if (!/\S+@\S+\.\S+/.test(email)) {
    return res.status(400).send('Invalid email format');
  }
  // Proceed to store the valid email
  // ...
});

The Role of Transparency

What I find particularly troubling about this incident is the lack of transparency. As developers, we value openness. It fosters a culture of trust and collaboration. If BrowserStack had communicated proactively—sharing details about what led to the leak, how they’re fixing it, and what steps they're taking to ensure it doesn't happen again—I think we'd all feel a bit better. It reminds me of a time when I worked with a team on a project, and we hit a major roadblock. Instead of keeping quiet, we held a meeting to discuss it openly. It brought us closer and ultimately led to a better solution.

Future of BrowserStack and Alternatives

Now, the big question is, what’s next for BrowserStack? Will they bounce back from this? In my opinion, they have a chance to turn this around. If they embrace radical transparency and prioritize user security, they could regain that trust. But if I’m being honest, I've started exploring some alternatives just in case. Tools like Sauce Labs and LambdaTest could be worth checking out. They’ve also got solid reputations. In my experience, it never hurts to have a backup plan.

Personal Takeaways

In wrapping up, this entire ordeal has left me with a couple of takeaways. First, always be cautious about where you store your data. Implementing secure coding practices isn’t just good practice; it’s a necessity. Second, transparency can make all the difference in tech. Users appreciate honesty, even when it’s bad news.

Ultimately, I hope BrowserStack takes this as a learning opportunity. We all make mistakes—yes, even us developers—but how we respond can define our next steps. I’m genuinely excited to see how they’ll handle this moving forward. And while it’s disappointing, it’s also a chance for all of us in tech to reflect and improve our own practices. So, what about you? How do you handle data security in your projects? Let’s chat about it over coffee next time!

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.

We replaced RAG with a virtual filesystem for our AI documentation assistant

Aman Shekhar — Sat, 04 Apr 2026 14:59:36 +0000

You know that moment when you're knee-deep in an AI project, and you hit a roadblock that makes you question your entire approach? I recently had one of those experiences while working on an AI documentation assistant. We were all set to use Retrieval-Augmented Generation (RAG) to enhance our assistant's ability to provide contextually relevant information. But then, something clicked. What if we could replace RAG with a virtual filesystem? It sounded crazy at first, but let me tell you, it ended up being one of the best decisions we made.

RAG: The Double-Edged Sword

Ever wondered why RAG has become such a buzzword in the AI community? I was initially drawn to it because, on paper, it brilliantly combines the strengths of retrieval-based and generative models. However, as I dove deeper into implementation, I started noticing some hiccups. For instance, when our assistant attempted to pull in context from vast datasets, it often returned results that sounded like they were written in a different universe. I found myself frequently massaging outputs to make them usable. Not exactly the streamlined experience I envisioned!

The Aha Moment

Then came that lightbulb moment. What if, instead of relying on RAG's sometimes erratic results, we could create a virtual filesystem where all our documentation lived? This way, the assistant could "browse" through the files and pull in information as needed, just like we do when we look for a specific file on our desktops. The concept was simple yet revolutionary for us. After all, who doesn’t want the assurance that the information they’re pulling is not only accurate but also contextually relevant?

Setting Up the Virtual Filesystem

I won’t sugarcoat it; implementing this was no walk in the park. We decided to use a combination of AWS S3 for storage and a Python-based backend to interact with the filesystem. Here's a snippet of the code I used to set up a simple API for fetching documentation from our virtual filesystem:

import boto3
from flask import Flask, jsonify

app = Flask(__name__)
s3 = boto3.client('s3')
BUCKET_NAME = 'your-bucket-name'

@app.route('/ docs/<file_name>', methods=['GET'])
def get_doc(file_name):
    try:
        file_content = s3.get_object(Bucket=BUCKET_NAME, Key=file_name)
        return jsonify(file_content['Body'].read().decode('utf-8')), 200
    except Exception as e:
        return jsonify({"error": str(e)}), 404

if __name__ == '__main__':
    app.run(debug=True)

What I learned here is that clear error handling is crucial. The last thing you want is your assistant crashing because it couldn't find a file!

The Benefits We Didn't Expect

Once we implemented the virtual filesystem, we noticed an immediate improvement in our assistant's performance. The ability to access files directly meant that the assistant was now providing answers that felt coherent and well-informed. Plus, we could easily update the documentation without worrying about breaking the assistant's response logic. This flexibility was a game-changer for our workflow.

Real-World Use Cases

I've been using this setup for various projects, from tech documentation to internal knowledge bases. One surprising success was when we integrated it into our onboarding process for new hires. Instead of making new team members sift through heaps of documents, our assistant could instantly pull up the most relevant information. It felt like magic watching the onboarding experience transform from tedious to efficient.

Challenges and Lessons Learned

Of course, it wasn't all sunshine and rainbows. One of the biggest challenges was dealing with file updates. If we updated a document but failed to refresh our assistant's cache, it could lead to outdated or incorrect info being served. After a few awkward moments with new hires trying to navigate this, we implemented a caching strategy with a TTL (Time To Live) that enforced regular updates.

Looking Ahead: What’s Next?

Now that we’ve seen success, I can’t help but wonder: what’s next? The promise of AI is still unfolding, and I'm genuinely excited about the potential for more advanced integrations. Imagine blending this virtual filesystem approach with real-time data analytics or even utilizing LLMs in a more controlled way.

In my opinion, we’re just scratching the surface of what’s possible. While I still see the value in RAG for certain applications, I think alternatives like our virtual filesystem can provide a more stable and reliable user experience.

Final Thoughts

If you’re considering a similar approach, here’s my advice: don’t hesitate to experiment. Mistakes and missteps are part of the journey. I won’t lie; I’ve had my share of those; but each one has taught me something valuable. At the end of the day, it’s about finding solutions that work for you and your team, and it’s okay to pivot when you find something that resonates better.

So, what do you think? Are you ready to ditch RAG for a virtual filesystem? Let's keep the conversation going!

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.

Decisions that eroded trust in Azure – by a former Azure Core engineer

Aman Shekhar — Fri, 03 Apr 2026 15:08:59 +0000

I remember the first time I deployed an application on Azure. The thrill of clicking that “Deploy” button, holding my breath as the Azure portal spun its wheels, and then—boom! The application was live. It felt like I’d conquered a mountain, and I was ready to take on the world. Fast forward a few years, and I transitioned to working as an Azure Core engineer. I was in the thick of it, witnessing decisions unfold that, in my opinion, started to erode trust in the platform. Ever wondered why some developers have become skeptical about Azure's reliability? Let’s break it down.

The Great Azure Promise

When I joined Azure, the vision was clear: to deliver a cloud service that developers could trust, a platform where scalability and resilience were part of the DNA. I was genuinely excited about the potential we had to empower other developers to innovate without the burden of infrastructure management. In my experience, Azure's services like Azure Functions or Azure SQL Database were a breath of fresh air, making it easy to focus on code rather than servers. But as time went on, I noticed cracks in the facade—decisions that didn’t quite align with that initial vision.

The Change in Priorities

One of the most significant changes I observed was a shift towards prioritizing corporate partnerships over community feedback. I remember a heated discussion in a meeting where we debated the integration of a new feature that users were clamoring for. Instead of listening to our community, the focus was primarily on aligning our offerings with a major corporate partner's needs. What if I told you that this shift created a rift? Developers felt like their voices were drowned out, and trust began to erode. Trust isn’t built overnight; it takes consistent, open communication, and that’s where I saw us falter.

The Azure Availability Saga

Let’s talk about service outages—a topic that sends shivers down the spine of any developer. I vividly recall the time when there was a massive, unexpected outage that affected countless applications across Azure. It was like watching a multi-car pileup in slow motion. Notifications were late, and the communication post-outage felt vague at best. I can’t tell you how many emails I got from clients asking why their services were down. It was a painful reminder that even the best technology can falter, but how you handle those failures is what defines trust.

In my personal projects, I had to plan for redundancy and failover strategies as a direct response to these outages, like implementing Azure Traffic Manager for global load balancing. But wouldn’t it be nice if we didn’t have to work so hard to build resilience against a service we were supposed to trust?

The Developer Experience Dilemma

As I continued my journey, I noticed the developer experience (DX) taking a back seat. We had tools that could simplify tasks but often lacked the polish that makes a developer’s life easier. For example, while Azure DevOps was powerful, the interface was clunky at times. I often found myself battling with the UI when I could’ve been writing code. I can still remember a late-night debugging session where I spent hours trying to figure out why a build wouldn’t trigger due to a poorly documented setting in the DevOps dashboard.

It became clear to me that investing in the developer experience should be a priority. A smooth DX leads to happier developers who trust the platform. But, in my experience, it often felt like we were “building for the enterprise” instead of the individual developer.

The Communication Gap

Have you ever tried to navigate a complex issue only to be met with jargon-laden documentation that felt like it was written by aliens? Yeah, I’ve been there. Azure’s documentation was a hit-or-miss experience. Sometimes it would be spot on, but then you'd hit a wall with poor explanations or outdated examples.

I learned the hard way that a good API is only as good as its documentation. I remember working with Azure Cognitive Services for natural language processing. A simple task turned into a rabbit hole of confusion because the documentation didn’t adequately cover how to handle specific edge cases. Aha moment? I started contributing to GitHub discussions and forums, pushing for clearer guidance. I genuinely believe that developers helping each other can rebuild some of that lost trust.

Embracing Open Source

One of the silver linings during my time at Azure was witnessing a push towards open-source initiatives. I’ve always been an advocate for open source, believing it fosters transparency and collaboration. I can’t emphasize enough how much I enjoyed working on the Azure SDK for Python. Seeing the community engage with the code, report bugs, and suggest features was refreshing.

But here’s the kicker: while open source can restore trust, it needs commitment. I’ve seen projects that began as open-source initiatives but fell victim to neglect. For open-source Azure projects to succeed, they need robust maintenance and community engagement. Otherwise, they risk becoming ghost towns, and that’s the last thing we want.

Personal Takeaways and Future Thoughts

Looking back, my journey with Azure has been a mixed bag of excitement and disillusionment. Trust isn’t something that can be taken for granted; it needs nurturing. The lessons I’ve learned? Keep the channels of communication open, prioritize developer experience, and truly listen to the community.

As I continue my path in tech, I’m hoping for a resurgence of trust in Azure. I still believe in its potential. My personal productivity tip? Always have a plan B—whether it’s a backup cloud provider or a local dev environment to fall back on when the wheels come off.

In a rapidly evolving tech landscape, let’s champion transparency, community involvement, and a focus on the developer experience. Maybe, just maybe, we can start to rebuild that trust, one decision at a time. What do you think? Are we ready to turn the tide 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.

Email obfuscation: What works in 2026?

Aman Shekhar — Thu, 02 Apr 2026 15:35:14 +0000

I remember the first time I got a spam email. It was a sunny afternoon, and I was sipping my coffee, waiting for a response from a potential client. Instead of an email from them, I saw a message promising me riches in a foreign land if I just shared my bank details. I chuckled, hit delete, and moved on. Fast forward a few years, and email spam has become a floating ocean of nuisance in our daily digital lives. As we move into 2026, I’ve been exploring a fascinating aspect of email security—email obfuscation. This clever tactic can help shield our addresses from bots and spammers, but what really works in 2026?

The State of Email Obfuscation

In my experience, email obfuscation isn’t just a passing trend; it’s a necessity. With the rise of AI and machine learning, spammers are getting craftier. I remember trying to protect my own email using basic HTML tricks like replacing the "@" symbol with "[at]" or using comments in the source code. But guess what? Those methods fell flat pretty quickly! Spambots evolved, and they started recognizing those tricks. So, I had to dig deeper and explore newer methods and technologies.

Aha Moment: The Power of JavaScript

While experimenting, I had my "aha" moment with JavaScript. I discovered that using JavaScript to display email addresses dynamically could be a game changer. For instance, instead of showing my email plainly, I could load it via a simple JavaScript function. Here’s a snippet I’ve used:

<script type="text/javascript">
    var user = "yourname";
    var domain = "example.com";
    document.write("<a href='mailto:" + user + "@" + domain + "'>" + user + "@" + domain + "</a>");
</script>

This way, the email address isn't visible in the HTML source code, making it harder for bots to scrape. I've noticed a significant drop in spam since I implemented this. It’s like hiding behind a digital curtain!

The CSS Trick: Layering Protection

But we can’t stop there! I often recommend layering protections. One day, while discussing this with a fellow dev, I realized that CSS could also play a role. I used a CSS method to create a “hidden” email display. By setting the email link's opacity to zero, I could visually hide it from prying eyes while still being accessible for human users. It’s a cool trick, but you need to ensure it doesn't affect user experience.

.hidden-email {
    color: transparent;
    text-decoration: none;
}

Combine that with JavaScript for added complexity, and you’ve got a decent shield against spambots.

Using CAPTCHAs to Verify Humans

Now, what if I told you that integrating CAPTCHAs could add an extra layer of protection? While it’s not exactly obfuscation, it’s a proactive approach to ensure that only real, human users can access your email. I’ve had mixed feelings about CAPTCHAs—they can be annoying, but they’re effective. I remember implementing Google’s reCAPTCHA on my contact forms, and it significantly reduced spam attempts.

The Role of Email Encoders

Another effective technique I stumbled upon is using email encoders. I came across a nifty tool called Email Encoder Pro, which converts your email into a format that’s still usable by people but nearly impossible for bots to decipher. It’s a bit like giving your email a disguise!

<script>
    document.write("<a href='mailto:" + encodeEmail("yourname@example.com") + "'>Contact Me</a>");
</script>

This approach has a learning curve, but once you get the hang of it, it’s a great addition to your toolkit.

The Debate: Is Obfuscation Enough?

Here’s where it gets controversial. Some argue that while obfuscation is important, it shouldn't be the only line of defense. I’ve had my share of conversations with security experts, and they often emphasize that no single method is foolproof. It's essential to stay vigilant, especially as spam techniques evolve. I’ve learned the hard way—after being targeted by a phishing scam where my details were nearly compromised. It taught me to never rely solely on one method.

Future Thoughts: The Road Ahead

As I look ahead to the future, I’m genuinely excited about where email security is headed. With advancements in AI, I can see tools emerging that’ll analyze patterns and prevent spam in real-time. Imagine an intelligent assistant that learns from your email interactions and alerts you of suspicious activity before it becomes a problem! Now that’s something to look forward to.

Personal Takeaways

So, what’s the bottom line? Email obfuscation is crucial, but it’s not the silver bullet. A combination of methods—JavaScript, CSS tricks, CAPTCHAs, and email encoders—can give you the protection you need in 2026 and beyond. My journey has taught me to be adaptable and stay informed about new trends and technologies.

What I'm currently trying to figure out is how to make these systems more user-friendly without compromising security. It’s a delicate balance, and I’m excited to keep exploring it. If you’ve tried any of these methods or found your own tricks, I’d love to hear your experiences! After all, sharing knowledge is what makes our developer community thrive.

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.

Show HN: 1-Bit Bonsai, the First Commercially Viable 1-Bit LLMs

Aman Shekhar — Wed, 01 Apr 2026 15:52:39 +0000

Ever wondered why we’re so obsessed with large language models (LLMs) these days? I mean, it feels like they’re everywhere—from powering chatbots that help us with customer queries to generating text that sounds surprisingly human. A few weeks ago, I stumbled upon an intriguing project called "1-Bit Bonsai" on Hacker News, claiming to be the first commercially viable 1-bit LLMs. At first, I thought, “What’s the catch?” But the more I explored, the more I got hooked.

The Beauty of 1-Bit Models

When I first learned about 1-bit models, I'll admit I was skeptical. I mean, how can a model that stores information in just one bit be effective? It felt like a DIY wooden toy in a world of high-tech gadgets. But then, I realized that this simplicity could lead to efficiency gains that are hard to ignore. What if I told you that these models could outperform their larger counterparts in certain tasks?

This is where my journey began. I wanted to dig deeper. I started off by experimenting with basic implementations, testing how effectively these models could understand and generate text. The initial results were surprisingly promising! I was able to use a simple setup to generate coherent text snippets based on minimal input. For example:

# Simple 1-bit model representation
class OneBitModel:
    def __init__(self):
        self.data = {}

    def train(self, input_data):
        for word in input_data.split():
            self.data[word] = self.data.get(word, 0) + 1

    def predict(self, word):
        return self.data.get(word, 0)

model = OneBitModel()
model.train("hello world hello")
print(model.predict("hello"))  # Output: 2

This code snippet showcases a minimalistic approach to building a 1-bit model. The training process is straightforward, and while it's rudimentary, it lays the groundwork for understanding how data can be compressed and processed in more interesting ways.

Real-World Applications

One of the major takeaways for me was the potential real-world applications of 1-bit LLMs. I started considering how businesses could leverage these models to save resources. In my last project, we were drowning in vast amounts of data to process customer queries. What if we could deploy a lightweight model trained just enough to handle repetitive tasks? The idea of transitioning from heavyweight models to something as light as 1-bit intrigued me.

I’ve seen firsthand how cost can balloon when you’re running large models—cloud costs, maintenance, and even the need for specialized hardware become real hurdles. With 1-Bit Bonsai, we could potentially democratize AI access for smaller businesses. Imagine a small startup that can compete on a level playing field without the overhead of massive computational resources!

Challenges and Lessons Learned

Of course, my journey hasn’t been without its bumps. I encountered various challenges—like the inevitable frustration when the model didn’t behave as expected. I remember a specific instance when I fed it complex sentences expecting some level of coherence, only to receive back what felt like word salad. That was my "aha!" moment, realizing that while 1-bit models are fascinating, they’re not magic. They require careful tuning and a deep understanding of what they can and can’t do.

One takeaway here is the importance of managing expectations. Just because something is new doesn’t mean it’s better. I’ve learned that sometimes, simpler solutions can yield results, but they also require a different approach to problem-solving. It’s a balance between complexity and effectiveness.

The Tech Stack: Tools & Services

I’ve been using tools like PyTorch and Hugging Face’s Transformers library to experiment with LLMs, and I can’t recommend them enough. They’ve streamlined my workflow significantly. However, with 1-Bit Bonsai, I found myself needing lighter libraries. I started exploring options like NumPy for basic operations and even custom implementations to better understand the model’s underpinnings.

Have you ever felt like you’re juggling too many libraries at once? I’ve been there, too! Sometimes, I prefer going back to the basics and building something from scratch. It not only helps in understanding the tech but also in troubleshooting down the line. Plus, it’s immensely satisfying to see a simple model kick into gear!

Ethical Considerations

As developers, we also have a responsibility to think about the ethical implications of AI. With 1-Bit Bonsai making waves, I can't help but wonder about the potential misuse of this technology. How easy would it be for someone to create a model that spreads misinformation using minimal resources?

I had a conversation with a fellow developer the other day about this, and we both agreed that while the tech is exciting, we need to tread carefully. The accessibility of AI should also come with ethical guidelines and responsible usage. What do you think? It’s a touchy topic, but one we can’t ignore.

Future Thoughts and Takeaways

So where do I see this heading? I’m genuinely excited about the implications of lightweight models like 1-Bit Bonsai. The efficiency, the accessibility, and the potential to create applications that fit into devices with limited resources are all things we should be focusing on.

As developers, we need to embrace this trend while being mindful of our responsibilities. I’m planning to incorporate 1-Bit models into my upcoming projects and can’t wait to see where it takes me. Maybe I'll even share my findings here!

In closing, I encourage you to explore the world of lightweight models. Whether you’re just starting or a seasoned pro, there's so much to learn and discover. Trust me, the journey is just as rewarding as the destination! What about you—have you tried working with 1-bit models or lightweight LLMs? I’d love to hear your experiences!

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.

Ollama is now powered by MLX on Apple Silicon in preview

Aman Shekhar — Tue, 31 Mar 2026 15:46:19 +0000

I've got to tell you—a few weeks ago, I found myself knee-deep in one of those "Why didn't I try this sooner?" moments. You know how it goes: you're juggling a dozen projects, trying to keep up with the endless stream of tech trends, and then something shiny catches your eye. For me, that something was Ollama, now powered by MLX on Apple Silicon in preview. And wow, it’s been a game-changer!

The Allure of MLX

Ever wondered why certain machine learning tools just seem to make everything easier? That’s what I felt when I started playing around with Ollama. It’s like discovering a secret ingredient that makes your favorite dish even more delicious. With MLX (Machine Learning Execution), Ollama is stepping up its game, especially for those of us rocking Apple Silicon. I’ve had my MacBook Air M1 for over a year now, and I can’t tell you how thrilled I am to see software truly optimized for the architecture.

I remember the first time I ran a model on my machine. It was an LLM for a side project involving text generation. The installation was a breeze, and, honestly, the performance was eye-opening. It felt like I was speeding down the highway while others were still stuck in traffic. The responsiveness and efficiency blew my mind. I’m genuinely excited about what this means for development.

The First Encounter

When I first heard about Ollama combining with MLX, I was skeptical. After all, I’ve seen many promising tools fall flat on their faces. Yet, I dove in anyway.

To get started, I ran the following command:

ollama pull llama2

This little line of code pulled the Llama 2 model and set everything up. I was amazed at how fast it downloaded and initialized. But then I hit a wall. I wanted to customize the model for a specific use case—fine-tuning it for a chatbot. It wasn’t as straightforward as I’d hoped.

Lessons from the Trenches

This is where my experience took a turn. I discovered that the documentation, while informative, left some gaps. I spent a good chunk of time fumbling around, trying to figure out how to adjust parameters. What I learned? Don’t underestimate the power of community forums.

I stumbled upon a GitHub issue that explained the nuances of fine-tuning in a way the official docs didn’t. It was like finding a flashlight in a dark cave. After a few tweaks to the parameters, I finally saw some promising results.

import ollama

model = ollama.load("llama2")
response = model.generate(prompt="Hello! How can I assist you today?")
print(response)

The output was surprisingly coherent! It was like chatting with a knowledgeable friend rather than an AI. This experience taught me a valuable lesson: often, the best insights come from fellow developers who have faced similar hurdles.

Optimizing for Apple Silicon

As I kept tinkering, I couldn’t help but marvel at the optimization for Apple Silicon. It’s like they designed it just for me—okay, not just for me, but you get the point! Each operation felt smooth and effortless, unlike some other tools I’ve used that seemed to struggle with resource allocation.

I’ve worked with different architectures in the past, including x86, and it’s clear that MLX makes the most of Apple’s M1 chip. It’s like switching from a bicycle to a sports car when it comes to speed and responsiveness. If you're on Apple Silicon and haven't tried this yet, you’re absolutely missing out.

Real-World Use Cases

Let’s talk about use cases. I’ve been experimenting with Ollama for a small startup project, developing a virtual assistant that helps users manage their tasks. The responses generated have been surprisingly on-point, accommodating both casual and formal contexts.

But here’s where my excitement turns a bit into caution. While Ollama is fantastic, I've encountered some limitations—like handling complex queries. The assistant sometimes struggles with nuanced questions, which can be frustrating. This is where I had to manage my expectations. I realized that, at least for now, it’s best suited for straightforward tasks rather than philosophical debates!

Troubleshooting Tips

If you’re thinking of diving into Ollama, here are a few troubleshooting tips from my own journey:

Check your environment: Make sure your dependencies are compatible with Apple Silicon. I once spent an evening debugging a model that wouldn’t run, only to discover I hadn’t updated Python.
Experiment with parameters: Don’t be afraid to play around with the settings. The "default" isn’t always the best fit for your specific application.
Engage with the community: Use forums as your go-to resource. Someone else has probably faced the same issues you’re encountering.

My Personal Takeaways

So, what’s the takeaway from all of this? First, I’m genuinely excited about the future of machine learning tools like Ollama, especially with MLX’s power behind it. I foresee a world where we can develop applications that feel less like software and more like personal assistants.

On the flip side, I remain cautiously optimistic. As we continue to push the boundaries of what’s possible with AI, it’s essential to remain grounded. Understanding the limitations—and being transparent about them—is key in building trust in these powerful technologies.

In the end, I’m looking forward to seeing how Ollama evolves. It’s made a real impact on my workflow, and I think it can do the same for many of you. Have you tried it yet? What’s your experience been like? Share your thoughts! I’d love to hear them over a virtual coffee 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.

ChatGPT won't let you type until Cloudflare reads your React state

Aman Shekhar — Mon, 30 Mar 2026 15:51:11 +0000

Ever had one of those moments where you feel like the universe is conspiring against you? Picture this: I'm deep into building a React application, eagerly implementing some cool features powered by ChatGPT. I’m fired up, ready to unleash my creativity, and then suddenly, I hit a wall. My app won’t let me type. It’s like a digital version of being stuck in traffic on a Monday morning. The culprit? Cloudflare’s request to read my React state. What an absurd twist, right?

The Cloudflare Conundrum

So, here’s what happened. I was using Cloudflare for my app, mainly for its powerful CDN and security features. I've had my fair share of wins with it in the past—faster load times, reduced latency, and all that jazz. But this time, as I was trying to integrate ChatGPT into my app, it felt like I was wrestling with a bear. The system was like, “Hold on, buddy. First, I need to check your React state.”

Ever wondered why you need to pass your data through layers that seem unnecessary? This is where I started to scratch my head. I mean, isn’t the beauty of React all about managing state locally? Why do I suddenly need Cloudflare’s permission slip to type? It was a frustrating early-morning realization that turned into a learning moment.

Unpacking the State Management

Before we dive deeper, let’s talk about how I typically manage state in my React apps. I’ve always been a fan of using hooks. The useState and useEffect combo has been my trusty sidekick. For this project, I was using a simple state structure:

const [inputText, setInputText] = useState('');

You know, the basics. But when I tried to implement real-time suggestions from ChatGPT, things got wonky. The app was trying to fetch suggestions based on the state, but with Cloudflare in the mix, I felt like I was stuck in a dance-off with my own code. Every time I typed something, Cloudflare would need to validate the state before moving forward.

The Aha Moment

After a few hours of digging around, I had my “Aha!” moment. I realized that Cloudflare’s caching could be affecting the way my app processed updates. I mean, think about it—when you have a complex setup where data needs to flow seamlessly, any bottleneck can throw a wrench in the works. I went back to my Cloudflare settings and tweaked the cache configuration.

Here's what I did:

Set up cache rules to ignore certain paths related to my app’s state.
Used the no-store directive for dynamic content.

This helped alleviate some of the pain points. I felt like a magician pulling a rabbit out of a hat. But let’s be real: it also reminded me that in web development, you can’t always rely on default settings. Sometimes, you’ve got to roll up your sleeves and get your hands dirty.

Troubleshooting Like a Pro

I’ve learned that troubleshooting is a huge part of being a developer. When something doesn’t work, it’s easy to get frustrated, but I’ve found that keeping calm and systematically analyzing the issue works wonders. Whether it’s checking logs, debugging with Chrome DevTools, or even revisiting documentation, taking a moment to breathe can lead to breakthroughs.

In this case, I also found that logging the state before it reached Cloudflare helped me understand exactly what data was being processed. It was like having a backstage pass to my app’s inner workings. I used:

console.log('Current State:', inputText);

Sometimes, the simplest solutions lead to the most profound insights.

Real-World Use Cases

You might be wondering how this applies beyond my little saga. Well, think about applications that rely heavily on real-time data—like chat apps or collaborative tools. The interplay between client-side state management and server-side validation is crucial, and missteps can lead to a frustrating user experience.

Whether you're building a public-facing app or an internal tool, understanding how services like Cloudflare interact with your setup can save you a lot of headaches down the road.

Future Thoughts and Personal Takeaways

Reflecting on my journey with this issue, I realized how critical it is to stay updated with the tools we use. Technology evolves, and what worked yesterday might not be the best approach today. I’m genuinely excited about the future of React, AI integrations, and cloud solutions, but it also means continually adapting.

If I could share one takeaway, it’s this: don’t shy away from experimenting. When something feels off, dig in. The best solutions often come from a blend of coding skills and a willingness to tweak and test until you find what works for you.

In closing, the unexpected hiccups, like Cloudflare making me pause my typing, may feel like a setback, but they often become the stories we share over coffee. So, whether you’re diving into AI, React, or any other tech endeavor, embrace the chaos, learn from it, and keep pushing forward. Who knows what thrilling tech adventure is waiting just around the corner?

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.