DEV Community: Abhay

Join Our Hacktoberfest Celebration and Contribute to Our Programming Blog, again!

Abhay — Thu, 02 Oct 2025 11:35:05 +0000

Hello there, tech enthusiasts, developers, and writers!

Are you looking to make your first open-source contribution this Hacktoberfest but not sure where to start?

We’ve built the perfect project for you:

👉 Commit & Contribute a community-driven tech blog where anyone can share knowledge, and no coding experience is required.

Yes, really. You can contribute with just Markdown and JSON and we’ll walk you through every step.

🎯 What Is This Project?

Commit & Contribute is a zero-CMS, file-based blog built with:

Next.js 15 (App Router)
TypeScript
Tailwind CSS
Markdown + JSON for content

But here’s the best part: you don’t need to run the app locally to contribute.

All you need to do is:

Write a short blog post in Markdown (content/posts/your-post.md)
Add your author profile in JSON (content/authors/your-username.json)
Submit a Pull Request on GitHub

That’s it! 🎉

💡 What Should You Write About?

We welcome tech-focused posts like:

“How I Built My First CLI Tool”
“Why I Switched from REST to GraphQL”
“Debugging a Weird TypeScript Error”
“My First Week with Next.js App Router”
“Lessons from My First Hacktoberfest”

We have some issues if you have no idea

Beginner? Perfect! Your fresh perspective is valuable.

Senior dev? Share a pro tip or war story.

📌 Posts must be original, respectful, and written by you (AI-generated content without human insight won’t be accepted).

🌟 See It Live

Once merged, your post appears on our live blog:

🔗 commit-and-contribute.dev

You’ll get your own author page, tags, and even a search feature!

❤️ We’re Here to Help

Stuck? Confused? Just say hi!

Join our Discord
Or reply to this post!

We actively mentor first-time contributors because everyone starts somewhere.

🎃 Let’s Make Hacktoberfest 2025 the Most Inclusive One Yet

Whether you’re a student, career-changer, or seasoned engineer your voice matters.

Ready to contribute?

➡️ Visit the repo now

And if you found this helpful, give the repo a ⭐ it helps others discover it too!

P.S. This post itself could be your inspiration for a contribution! 😉

Go write your own version, share your journey, and inspire someone else to hit “Contribute.”

Happy coding—and happy Hacktoberfest! 🐝💻

🔗 Repo: Grimm-s-Alchemy-Chamber/commit-and-contribute

📄 Contribution Guide: CONTRIBUTING.md

🧠 Auto-Evaluating Chatbots with GenAI: The Pipeline, The Prompts, and The Proof

Abhay — Thu, 10 Apr 2025 15:27:53 +0000

Chatbots are getting scary good — but evaluating them? That’s still a pain. BLEU and ROUGE scores feel like trying to judge a movie by its subtitles. Human evaluation is time-consuming, inconsistent, and honestly… nobody has time for that.

So here’s the question I tackled in this project:
Can we let an LLM evaluate other LLMs?

Spoiler: Yep. And it’s shockingly effective.

The Big Idea: LLM Rating LLM 💡

We built an Auto-Eval system using Google’s Gemini 2.0 Flash model to rate chatbot responses on:

✅ Relevance – Does it actually answer the question?

✅ Helpfulness – Is the answer useful or just fluff?

✅ Clarity – Can a human actually understand it?

✅ Factual Accuracy – Is it hallucinating or nah?

And we didn’t just invent our own data — we pulled real conversations from the OpenAssistant dataset (OASST1). These are crowdsourced human-assistant chats, so it’s the real deal.

Setup: Let’s Get Nerdy ⚙️

Step 1: Load the Dataset

We used Hugging Face’s datasets library to load OpenAssistant’s training data and converted it to a Pandas DataFrame.

from datasets import load_dataset

oasst = load_dataset("OpenAssistant/oasst1")
df = oasst["train"].to_pandas()

Step 2: Extract Prompt-Response Pairs

We filtered English conversations and merged assistant replies with the prompts that triggered them.

df = df[df['role'].isin(['prompter', 'assistant'])][['message_id', 'parent_id', 'text', 'role', 'lang']]
df = df[df['lang'] == 'en']

merged = df.merge(df, left_on="parent_id", right_on="message_id", suffixes=("_reply", "_prompt"))
merged = merged[['text_prompt', 'text_reply']].rename(columns={'text_prompt': 'prompt', 'text_reply': 'response'})

Prompt Engineering + Gemini Setup 🤖

We used few-shot prompting to make Gemini behave like an evaluator and return structured scores (in JSON format).

Here’s the eval prompt we send:

def build_eval_prompt(prompt, response):
    return f"""
You are an evaluator. Rate this response to a user prompt.

Rate from 1 to 5 on:
- Relevance
- Helpfulness
- Clarity
- Factual accuracy

Return ONLY valid JSON:
{{
  "relevance": X,
  "helpfulness": X,
  "clarity": X,
  "factuality": X
}}

Prompt: {prompt}
Response: {response}
"""

And then we just hit Gemini with that:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")
model = genai.GenerativeModel("gemini-2.0-flash")

response = model.generate_content(build_eval_prompt(prompt, response))

Running the Evaluation Loop 🧪

We ran the model on a sample of 15 prompt-response pairs and parsed the scores:

ratings = []

for _, row in sampled.iterrows():
    try:
        res = model.generate_content(build_eval_prompt(row['prompt'], row['response']))
        json_block = res.text[res.text.find('{'):res.text.rfind('}')+1]
        score = json.loads(json_block)
        score.update(row)
        ratings.append(score)
    except Exception as e:
        print("Error:", e)

Boom. Now we have an LLM scoring LLMs. Matrix-style.

Visualizing the Scores 📊

We saved everything to a CSV and used a Seaborn boxplot to get the vibes:

import seaborn as sns
import matplotlib.pyplot as plt

ratings_df = pd.DataFrame(ratings)
sns.boxplot(data=ratings_df[['relevance', 'helpfulness', 'clarity', 'factuality']])
plt.title("LLM Auto-Eval Score Distribution")
plt.show()

And the results? Pretty solid. Some outliers, but Gemini gave reasonable scores across all four dimensions.

Takeaways 🔍

✅ This works. Gemini can evaluate chatbot responses consistently.

🎯 It scales. No need to bug your friends to rate 200 replies.

🤖 Model comparisons just got easier. Want to compare GPT vs Claude vs Mistral? Auto-eval it.

What’s Next? 🛣️

📈 Add more examples and multiple models for A/B testing.

🤯 Detect hallucinations automatically.

🧑‍⚖️ Compare LLM vs human evaluations — who rates better?

🧪 Try It Yourself

Want to peek under the hood or run it with your own data?

👉 Check out the full notebook on Kaggle

Clone it, tweak it, break it (just don’t blame me 😅).

P.S : This post was rated 5/5 on clarity by my cat. And 2/5 on factuality by my anxiety.

🧠 Evaluating Chatbots with GenAI : The Problem, The Potential, and The Plan

Abhay — Thu, 10 Apr 2025 15:27:27 +0000

Chatbots are evolving fast. Evaluating them? Not so much.

5-Day Generative AI Intensive course by Google & Kaggle, where we explored how to apply cutting-edge GenAI tools in real-world projects. At the end of the course, we were challenged to build a capstone project around one big question:

🧩 How can we use GenAI to solve a problem that traditionally required human effort, manual work, or complex logic?

So I zeroed in on one of the trickiest challenges in the LLM space:
How do you evaluate chatbot responses without human reviewers?

The Problem with Evaluating LLMs 🤖

Imagine building a chatbot. It talks. It answers. It vibes. But… how do you know it’s good?

You can’t just count matching words. That’s like rating a movie by checking if it includes the word “explosion.”
Asking humans to evaluate hundreds of responses? Painful, slow, inconsistent, and not scalable.

And yet, evaluation is critical. If you’re:

Comparing multiple LLMs (GPT-4 vs Claude vs Mistral)
Fine-tuning models on your own data
Shipping AI chat features in your product

…you need to know which outputs suck and why— fast.

Enter GenAI Evaluation: LLMs Judging LLMs 🧠

Here’s where things get spicy.

Instead of manually evaluating responses, what if we could get an LLM to do it for us?

That’s the core idea of my capstone:

Use a GenAI model (Gemini 2.0 Flash) to rate chatbot responses on key quality metrics.

This isn’t just automating a task — it’s using intelligence to evaluate other intelligence. Wild, right?

Capstone Project Requirements 📋

The project had to meet a few key criteria:

Requirement ✅	Our Approach 💡
Use real-world data	We used the OpenAssistant Dataset (OASST1), a huge collection of human-assistant conversations.
Solve a practical problem	We tackled the LLM evaluation bottleneck, a major issue in GenAI dev workflows.
Leverage GenAI capabilities	We used Gemini 2.0 Flash to generate scores on relevance, helpfulness, clarity, and factuality.
Automate a previously manual process	We created a fully autonomous pipeline for evaluating chatbot responses.

This wasn’t just for fun — it had real applications, and could be extended into production tools.

GenAI Capabilities We Used ⚙️

Here’s what made this project tick:

Few-shot prompting
We added scoring examples to the prompt so the model understood the rating scale. Like teaching a mini-AI to become a harsh movie critic.
Structured Output (JSON)
Instead of vague “This looks good” answers, Gemini returned proper JSON like:

{
  "relevance": 4,
  "helpfulness": 5,
  "clarity": 4,
  "factuality": 3
}

Machine-readable. Developer-friendly 🤌🏻 .

Gen AI evaluation Used Gemini to auto-evaluate chatbot responses on multiple dimensions.

Real-World Use Cases 🔥

This approach isn’t just for academic flexing — it’s legit useful for:

✅ Startup teams testing new AI chat features
✅ Researchers comparing open-source LLMs
✅ Devs fine-tuning models on their own datasets
✅ QA pipelines for chatbot apps

And the best part? It scales like crazy. Want to evaluate 1,000 responses overnight? Just batch it and go.

What’s Next ?? 👀

Now that we’ve covered the “why” — get ready for the “how.”

In Next Post, I’ll walk you through:

Setting up the dataset (OASST1)
Extracting prompt-response pairs
Prompting Gemini to score responses
Parsing and analyzing the results
Visualizing it all with plots and metrics

If you’re into GenAI, data science, or just building cool stuff — you’re gonna love it.

📌 TL;DR

Evaluating LLMs manually is slow, messy, and subjective. So I built an auto-eval system using Google’s Gemini to score chatbot responses on relevance, clarity, helpfulness, and factuality — no humans needed. Part 2 drops soon with all the nerdy build details.

My Experience at Build Bengaluru 2024

Abhay — Fri, 20 Dec 2024 11:52:12 +0000

Earlier this week, I attended Build Bengaluru 2024, an event by Snowflake focused on generative AI, data engineering, and their ecosystem. What drew me in was the agenda—it promised to deliver insights into concepts like Retrieval-Augmented Generation (RAG) and AI app development, areas I’ve been deeply interested in exploring for my projects.

General Impressions

The event kicked off with a bustling crowd, which honestly surprised me. Even though I had pre-registered, there was still a queue at the registration desk. But the atmosphere made up for the wait—it was buzzing with energy and curiosity.

Key Sessions Attended

Session 1: Data Power to Chatbot Power—Engineering the Perfect RAG Snowball

Speaker: Daniel Myers

Key Highlights:

An in-depth explanation of Retrieval-Augmented Generation (RAG) with Cortex Search and its enterprise applications.
Features like Hybrid Retrieval, Cortex Analyst, and Cortex Chat API were thoroughly discussed.

Personal Takeaway:

This session was incredibly impactful as it aligns directly with my ongoing projects and future plans, particularly in exploring RAG implementations. Stay tuned for a dedicated blog post where I dive deeper into this topic and its applications!

Session 2: Building Enterprise-Grade AI Apps with Snowflake Native Apps Using Snowpark Container Services

Speaker: Harish Chintakunta

Key Highlights:

Showcased how Snowflake Native Apps simplify AI app development and deployment.
Explained seamless workflows through integration with Git, REST APIs, Python, and Snowflake CLI.
Emphasized security with in-platform app execution.

Session 3: Harnessing Generative AI with Snowflake and AWS

Speakers: Avinash Venkatagiri and Bharath Suresh

Key Highlights:

Insights into Amazon Bedrock’s diverse foundation models and their integration with Snowflake for contextualized AI applications.
Demonstrated the capabilities of the AWS Generative AI Stack for scalable AI model development and deployment.

Insights for My Projects

Another highlight was learning about Snowflake Native Notebooks. The ability to train models directly and leverage Snowflake’s integrations, like Streamlit, felt like a game-changer. It simplifies the process of experimenting with models and speeds up development—a feature I’m excited to explore further.

Reflections

While I didn’t interact much with other attendees, the event itself offered plenty of value. Snowflake’s focus on generative AI and data apps feels relevant for anyone working in the AI/ML space.

If you’re considering attending Build next year, I’d highly recommend it. Whether you’re looking to deepen your technical knowledge or discover new tools for your workflow, it’s an excellent opportunity to stay ahead in the fast-evolving world of AI and data engineering.

Stay tuned for a separate deep dive into the "Data Power to Chatbot Power" session—it deserves a post of its own!

The Hackathon That Nearly Broke Us

Abhay — Tue, 17 Dec 2024 08:47:44 +0000

In 2022, I attended my very first hackathon—a state-level competition called Sentinel Hack 2.0.

ID cards from our first hackathon—symbols of chaos, teamwork, and a wild learning curve

We were second-year college students with zero experience, an outdated laptop, and a naive confidence that we could just “figure it out” as we went. We had no clue what a hackathon actually demanded.

What followed was pure chaos—a rollercoaster of confusion, panic, brainstorming, and quick thinking. But by the end, we walked out with something incredible:

A project idea we named Brisk Steer.
A handful of hard-earned lessons in teamwork, problem-solving, and quick innovation.
And memories that still make me laugh to this day.

Here’s the story of how we turned a near disaster into something meaningful.

Why We Signed Up

We first heard about Sentinel Hack 2.0 when the organizing team visited our college. It was a 24-hour hackathon. Coding non-stop for an entire day sounded like an adventure—how hard could it be, right?

We didn’t have any big plans or goals. We weren’t aiming to win. We just thought:

“Let’s go, code as much as we can, and have fun.”

But here’s what no one tells you: hackathons aren’t just about writing code. They’re about solving real problems, innovating on the fly, and learning how to work under real pressure.

We were about to find that out the hard way.

Our Big Mistake

We entered the hackathon feeling pretty good. We had prepared an encryption algorithm beforehand, so we thought we were all set.

When the judges came around for the first evaluation, we proudly explained our work. That’s when one of them asked:

“What improvement does this provide over existing industry standards?”

Boom. Silence.

We froze. None of us had an answer.

We had no idea that hackathons were about building something new or improving an existing solution.

The judges weren’t mean about it—they gave us 3 hours to come up with a new idea. But in that moment, we felt embarrassed, nervous, and completely clueless.

Giving up wasn’t an option, though. So we huddled together, started throwing out ideas, and hoped something would stick.

How Brisk Steer Was Born

Prepping for the big moment: The MacBook Pro displaying our presentation slides—where the ideas finally came together before we presented

As we brainstormed, we focused on real-world problems. That’s when it hit us:

In heavy traffic, rescue vehicle sirens get lost in the chaos.

Drivers struggle to figure out where the ambulance is coming from and where it’s heading.

If you’ve ever been in a traffic jam in a big city like Bangalore, you know what I’m talking about. Frustrated honking, crowded roads, and an ambulance siren lost somewhere in the noise. In those situations, every second matters.

That frustration sparked the idea of Brisk Steer:

A system to help clear traffic for rescue vehicles like ambulances and fire trucks.
A navigation app for rescue drivers to find the best route.
Hardware installed on traffic lights to alert drivers about the direction of the incoming rescue vehicle.

We couldn’t believe we came up with something this promising under such pressure. It was a mix of quick thinking, real-world frustration, and a whole lot of teamwork.

Limited Resources, Unlimited Effort

Now that we had the idea, the next challenge was building a Minimum Viable Product (MVP) in the few hours we had left.

Our Tools and Limitations

Old meets new: The tractor working alongside a Raspberry Pi 4, surrounded by a tangle of wires and moue—a true hackathon setup fueled by creativity and chaos.

My Dell Vostro 1015—a laptop so old it overheated and lagged at the worst times.
also another couple of slightly good laptops 3 to be precise
A Raspberry Pi 4 I happened to have lying around. (Honestly, I had tried using it as a replacement for my laptop because it was faster!)

The Execution

A chaotic but functional setup: The Dell Vostro 1015, Raspberry Pi 4, and multiple laptops working together, with wires and Ethernet cables

Our MVP was basic:

The app would send a signal to the Raspberry Pi.
The Raspberry Pi would simulate the traffic lights showing the direction of the rescue vehicle.

Connecting the Raspberry Pi to my laptop wasn’t easy. We hit roadblocks, panicked, and at times wondered if we could even make it work. But somehow, through combined effort and pure determination, we pulled it off.

Was it perfect? No.

But it worked well enough for a demo.

What the Judges Said

When we presented Brisk Steer to the judges, they had mixed feedback.

On the one hand, they appreciated our quick thinking and loved the potential of the idea. On the other hand, they raised valid concerns:

How would this scale in a city?
Wouldn’t installing hardware on traffic lights be expensive and complicated?

They were right, of course. But for us, hearing positive feedback on the idea itself was a huge win.

We didn’t have all the answers yet—but we had proven to ourselves that we could come up with something innovative, even under pressure.

What We Learned

We didn’t win the hackathon, but honestly, that didn’t matter. Here’s what we walked away with:

1. Quick Thinking Matters

In just 3 hours, we went from clueless to having a working MVP. We learned how to brainstorm fast, identify a problem, and create a solution on the spot.

2. Teamwork Is Everything

We split tasks, collaborated equally, and supported each other when things got tough. As the team leader, I realized how important it is to work together, especially under pressure.

3. Constraints Push Innovation

With limited time, old hardware, and no prior experience, we were forced to get creative. Sometimes, those constraints are what lead to the best ideas.

To Anyone “Not Ready” for a Hackathon

If you’re nervous about attending a hackathon, here’s my advice:

Just show up. Don’t worry about winning or being “ready.” The experience itself is the real prize.
Leave your ego behind. You don’t need to know everything. Hackathons are about learning.
Go with friends. It’s a memory you’ll cherish—coding, laughing, and staying up all night together.

Looking Back

Since that hackathon, I haven’t revisited Brisk Steer. But recently, I’ve been thinking about refining it and publishing it as an open-source solution. Who knows? Maybe it can help solve a real-world problem someday.

From Mistakes to Memories

That first hackathon taught me so much. We started off with no plan, made mistakes, and struggled through the night. But by the end, we walked out with:

An innovative idea.
Lessons in teamwork, quick thinking, and resilience.
And memories I’ll never forget.

Hackathons aren’t just competitions—they’re opportunities to learn, grow, and challenge yourself. If you ever get a chance to attend one, here’s all you need to do:

Show up, give it your best, and enjoy the ride.

Have you ever solved a problem under pressure? I’d love to hear your story—share it in the comments below!

How My Old Laptop Taught Me More About Coding Than Any Course Ever Could

Abhay — Mon, 16 Dec 2024 12:58:59 +0000

Most people see laptops as tools. For me, my 11-year-old Dell, lovingly called “Tractor” for its noisy fan, was more than that—it was a companion, a challenge, and an unyielding teacher. From its broken hinge to its dead keyboard, Tractor pushed me to my limits at every step. But it also shaped me into the developer I am today.

Facing the Challenges Head-On

This little companion helped me debug my way through countless errors on an aging Dell Vostro 1015. Who needs a coding partner when you have a curious kitten?

Tractor wasn’t just old; it was stubborn. Booting up sometimes took over an hour, and installing software often meant hunting down compatible versions from the depths of obscure forums. Its fan, obstructed by a worn-out casing, growled like a tractor plowing fields. And crashes? They were a regular occurrence, often right after a painfully long compilation process.

On top of that, Tractor’s keyboard had given up, and its hinge was broken, making it a delicate balancing act just to use the screen. While my peers worked on modern laptops, I was stuck with this antique. But rather than letting it hold me back, I leaned into its challenges.

Turning Obstacles Into Opportunities

From struggling on a single old laptop to building my own little workspace—here’s how I evolved my setup to code better, learn faster, and dream bigger.

The limitations of Tractor forced me to adapt and think critically. While my classmates completed tasks in five simple steps, I often had to find workarounds for every single one. Tasks that seemed trivial to others became opportunities for me to develop creative problem-solving skills. Debugging, optimizing performance, and learning how systems worked under the hood weren’t just options—they were survival tactics.

When Tractor couldn’t handle advanced projects, I turned to cloud solutions. Using AWS EC2 instances allowed me to continue developing when my local machine couldn’t keep up. At the time, I didn’t realize I was gaining early exposure to cloud computing, but those skills later became invaluable in my journey as a backend and AI/ML engineer.

A Fresh Start with New Tools

From debugging code on an aging Dell Vostro 1015 to upgrading to a MacBook Pro, both my skills—and my kitten—have grown along the way. 🐾
P.S: I didn't have any good pics of MacBook 😅

In 2022, I moved to a 2011 MacBook Pro—still outdated, but a significant step up. While the MacBook’s performance was better, its inability to support modern macOS versions brought its own set of challenges. I had to find workarounds for newer software, just as I had with Tractor. But after years of overcoming obstacles, nothing felt impossible anymore.

I brought the Dragon Home 🐉

Looking back, my upgrade to a newer machine, the MSI GF63 Thin, was a significant step forward. It featured an 11th Generation Intel Core i7-11800H processor, 8GB DDR4 RAM, 512GB NVMe PCIe Gen3x4 SSD, and the NVIDIA GeForce RTX 3050 graphics card with 4GB of GDDR6 memory. This combination provided the performance boost I needed for demanding tasks, smoother multitasking, faster load times, and more reliable performance compared to the older machines I was used to. The improved graphics card also enhanced my development environment and light gaming experiences. This upgrade revealed just how much my previous struggles had prepared me for the challenges that lay ahead.

Dual booted the dragon the very next day it was brought

What I Learned Along the Way

Tractor reshaped how I approached challenges, teaching me to think critically and develop creative solutions. Adaptability became second nature when working with its constant limitations. While it was frustrating to deal with crashes and long boot times, those moments tested my tolerance for setbacks. As for patience.... well, I’m still working on it.

This experience also fostered a deep empathy for others struggling with limited resources. I know what it feels like, which is why I’m always willing to share tips, tools, and workarounds with those in similar situations. Lastly, Tractor taught me gratitude. While the old machine instilled resilience, my newer tools have made my work more efficient, and I now have an immense appreciation for progress.

Advice for Others in Similar Situations

If you’re stuck with an old machine, don’t lose hope. There are practical strategies that can ease your challenges and make the most of your resources. First, consider switching to a lightweight system like Linux, specifically Ubuntu, to optimize performance on older hardware. You’d be amazed at how much smoother things can run. When your local machine can’t handle heavy workloads, don’t hesitate to leverage cloud tools like AWS EC2 instances to offload demanding tasks. Additionally, always make backing up your work a priority; older machines are prone to crashes, so regularly use Git and keep multiple backups to safeguard your progress. Finally, embrace creativity in downtime—if you’re waiting for your laptop to boot or compile, utilize that time for planning, writing pseudocode, or researching better workflows. These small adjustments can significantly enhance your experience while working with limited resources.

The Moments That Made Me Smile (and Groan)

There were plenty of moments with Tractor that, in hindsight, are almost funny. Waiting an hour for the laptop to boot was a regular occurrence. Sometimes, after a painfully long compilation, the system would immediately crash. And let’s not forget the noise—a grinding, clunky fan that sounded like a tractor in overdrive.

Over time, Tractor became more than just a machine. It was part of my personality. It taught me patience, resilience, and the value of hard work. I even gave it its quirky nickname because, honestly, it earned it.

The Final Takeaway

Tractor may have been loud, slow, and outdated, but it played a significant role in shaping my journey as a developer. It prepared me for challenges I never anticipated and made me the developer I am today. When I look back on my journey, I realize that my struggles with Tractor weren’t just technical hurdles—they were life lessons in disguise.

To anyone out there working on an old, underpowered machine: hang in there. The skills and resilience you’re building today will stay with you forever. And who knows? Someday, you might look back on your struggles with a smile and a story worth sharing.

To wrap things up, I’d like to share a glimpse of the setup I currently use—a testament to how far I’ve come since my days with Tractor.

Why Pen and Paper Still Rule My Coding Process (And No, It’s Not Because I’m Old-School)

Abhay — Fri, 13 Dec 2024 07:30:17 +0000

If someone asked me to describe my early days of coding, I wouldn’t talk about IDEs or debugging in front of a computer. No, my journey began with something way simpler—a pen, a notebook, and a confused look on my face as I tried to figure out what the heck an algorithm was.

Back in pre-university, C++ was part of the curriculum, and as much as I loved the idea of coding, the reality was... complicated. Theoretical classes didn’t click. Concepts felt abstract, and I just couldn’t connect them to anything real. I’m the kind of person who needs to know why something works and how to use it before I can actually learn it. (Spoiler alert: I’m still like this.)

Then one day, during a mandatory study hour, something clicked.

The Day It All Started Making Sense

Picture this, I’m bored out of my mind, sitting in class with my C++ textbook, pretending to study. Instead of revisiting the same concepts I didn’t understand, I decided to flip through the pages ahead. And then—lightbulb moment—I started seeing patterns in the example programs.

What if I wrote down what the program was doing, step by step? Suddenly, I wasn’t just reading the program; I was extracting its pseudocode (I didn't even know what they are called ). From there, I started writing the algorithms and drawing flowcharts to visualize the process.

Without realizing it, I was reverse-engineering the programs. And just like that, the chaos started to make sense.

Why I Still Swear by It

Even now, years later, I still go back to pen and paper. It’s not about being “old-school.” It’s about clarity. Writing things out forces me to slow down and think critically about what I’m trying to accomplish.

In a world where everything moves so fast, taking a step back and simplifying things feels… grounding.

How It Helped Me

The pen-and-paper approach changed everything. Suddenly, concepts clicked. Debugging felt less like guesswork and more like solving a puzzle. Writing down pseudocode on paper became my secret weapon, helping me untangle even the trickiest problems.

Encouragement for Beginners

To every beginner out there don’t rush to the IDE. Take a step back, grab a notebook, and map out your thoughts. This approach may feel slower at first, but it builds the kind of foundation that will serve you for years.

Remember, coding isn’t just syntax—it’s logic, creativity, and problem-solving. So, start with pen and paper and experience the magic.

Coding Isn’t Typing. It’s Thinking.

Here’s the thing no one tells you coding doesn’t start with firing up an IDE and smashing your keyboard like a hacker in a Hollywood movie. No. Coding starts with your brain… and, in my case, a cheap ballpoint pen and whatever notebook I could grab. Writing code on paper first wasn’t just helpful—it was a sanity-saver. Why? Because IDEs are mean. They’ll yell at you with errors the moment you mess up. A notebook, though? It’s quiet. Kind. Patient. It won’t judge you if your “algorithm” looks like a shopping list.

I had the best mentor—a man who saw my cluelessness and didn’t run the other way. Instead, he handed me the tools to figure things out on my own. He’d guide me when I was stuck but never spoon-feed me answers. That’s how I learned that struggling is a feature, not a bug, in coding. He made me realize that coding is 20% writing code and 80% trying to figure out why it doesn’t work.

Why I Still Use Pen and Paper

Now, I know what you’re thinking: “This is 2024, not the Stone Age. Why use pen and paper when there’s ChatGPT?” First, ouch. Second, because it works.

Writing pseudocode and algorithms forces me to slow down and actually think. It’s like stretching before a workout—you don’t want to skip it unless you’re okay pulling a mental muscle. Plus, there’s something satisfying about crossing out bad ideas on paper. It’s cathartic.

I mean, it'll be 2025 soon. And while ChatGPT is a total lifesaver (seriously, it’s like having a coding partner who never sleeps), there’s something about the simplicity of pen and paper that still helps me cut through the noise. It’s like the ultimate balance—combine the mental clarity of paper with the genius of ChatGPT. It’s the best of both worlds.

Conclusion: Coding is a Journey

Coding is more than typing lines of code; it’s about thinking critically and solving problems. By starting with pen and paper, you’re setting yourself up for success. I’d love to hear your thoughts—have you tried this approach before? Share your experiences in the comments or reach out to me on LinkedIn or Instagram.

Let’s learn and grow together! 🚀

PS: A Quick Thanks to My Mentor

If my mentor ever happens to read this, huge thanks for not giving up on me during those frustrating moments when my code refused to cooperate. You didn’t just hand me the answers—you made sure I learned how to find them myself. I’m pretty sure you’ve saved me hours of confusion, and I definitely owe you more than just a coffee for all the guidance!

Recording My Coding Journey

Abhay — Thu, 12 Dec 2024 19:41:00 +0000

Introduction

I’ve always wanted to start a blog, but during my college years, I never really found the time. However, as I delved deeper into coding and embraced my project-based learning style, I realized I needed to share my experiences. One of the main reasons I decided to start this blog is to create an online presence and leave my mark on the internet. Plus, as a project-based learner, I often face obstacles that I need to overcome—by documenting how I solve these challenges, I can reflect on my progress, learn from my mistakes, and hopefully help others who might be stuck in the same places I’ve been.

Why I’m Documenting My Journey

For me, coding is more than just about writing code—it's about learning from my experiences and sharing that knowledge. I’m deeply passionate about open source, and I believe that sharing my journey could make a difference for someone else. Blogs have been a huge help to me in the past, whether I was troubleshooting a bug or learning a new framework. Maybe, just maybe, my experiences can be the key to solving someone else’s problem.

Goals for This Blog

While this blog will be a place for my personal growth, I also aim to showcase who I am—my personality, my struggles, and my successes. This blog will be an extension of my portfolio, reflecting my journey as a coder and an open-source enthusiast. It will include a mix of technical posts on coding, projects, and tutorials, but it will also capture the essence of my experiences in the tech world.

Some key themes I plan to explore are:

How I started my coding journey
The lessons I've learned over the years
Challenges I’ve faced (and how I overcame them)
The things college didn’t teach me
Technologies I’m passionate about (C++, web technologies, Python, Flask, AI/ML)
Insights gained from attending tech conferences
Open-source contributions

What You Can Expect

This blog will feature several types of content, all grounded in my personal experience:

Project Showcases: I’ll highlight the projects I work on, including how I approach them, the challenges I face, and the lessons I learn.
Coding Tutorials: I plan to provide step-by-step guides on building things like CLI apps and APIs, including tips and tricks that will help you with your own projects.
Personal Insights: I’ll write about the essential things that you don’t necessarily learn in college—whether it’s how to tackle a project or insights into the world of tech.

How Often Will I Post?

I plan to update my blog three times a week, with a mix of technical tutorials, project showcases, and reflections on my experiences. I already have a few ideas lined up, and I’m excited to start sharing them with you!

Engage with Me!

I’d love for you to engage with me as I embark on this journey. Feel free to comment on my posts, reach out via LinkedIn or Instagram, and share your thoughts. I’m always happy to chat, whether it's feedback, advice, or simply discussing a project or concept.

This blog also encourages anyone who wants to share their own journey. Whether you’re a beginner or an experienced programmer, your experiences are valuable, and I invite you to join the conversation.

Exploring Open Source AI/ML and Sustainable Data Storage: Day 1 at Open Source India Conference

Abhay — Thu, 19 Oct 2023 19:26:17 +0000

Imagine stepping into a world of innovation, where technology enthusiasts gather to discuss, share, and learn about the latest trends in open-source technology. That's precisely what Day 1 of the Open Source India Conference offered. We were there, and let me tell you, it was an enlightening experience. We attended some of the key sessions and workshops, where industry experts shared their wisdom and insights.

Open Source AI/ML – AWS and India Opportunity

Dr. Biswajit Mohapatra's session got us off to an exciting start. He talked about the potential of open-source Artificial Intelligence and Machine Learning (AI/ML) solutions, particularly in India, and how AWS is a game-changer in this arena. He opened our eyes to the endless opportunities for innovation and growth.

Harnessing The Power of Text Embedding

Next up was Srikar Yekollu, who took us on a journey through the world of text embedding, a fundamental technique in natural language processing. We dived deep into the applications of text embedding and saw how it's making a real impact in AI and data science.

Green Data Storage in the Open Source World

Ajeya Motaganahalli had an important message to share: the importance of green data storage. In a world that's pushing for sustainability, his insights on eco-friendly data storage solutions and open-sources thought-provoking.

Embracing Inner Sourcing Towards Open Sourcing

// Detect dark theme var iframe = document.getElementById('tweet-1714907737581322658-88'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1714907737581322658&theme=dark" }
The speakers from Siemens Technology Services wrapped up the morning session with an inspiring talk about "inner sourcing." They discussed how fostering collaboration and innovation within organizations can drive open-source development and create a culture of sharing and growth.

Workshop: Mastering Site24x7: A Hands-On Monitoring Workshop

// Detect dark theme var iframe = document.getElementById('tweet-1714974198547026380-409'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1714974198547026380&theme=dark" }
The day concluded with a hands-on workshop led by Sarath Chandran. Here, we delved into the world of monitoring tools using Site24x7. It was a valuable opportunity to learn essential monitoring techniques, vital in today's tech-driven world.

Also got some swags
// Detect dark theme var iframe = document.getElementById('tweet-1715047794564858280-429'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=1715047794564858280&theme=dark" }

Virtual Workshop on Low-Code Contributions for Hacktoberfest - Perfect for Beginners!

Abhay — Fri, 06 Oct 2023 06:21:32 +0000

We are thrilled to announce a special virtual workshop tailored specifically for beginners, designed to help you make low code contributions for Hacktoberfest. Whether you're taking your first steps in the tech world or looking to dip your toes into open source, this event is your perfect starting point.

Event Details:

Date: 8 October 2023
Day: Sunday
Time: 11 AM
Platform: Discord

What will be covered in the event :

What is hacktoberfest and open-source?
How to register and successfully complete Hacktoberfest ?
Why contribute to open source?
Git GitHub basic and first contribution
How to make low code contributions to our repo

Important Things to Note:

This event is tailored for beginners, and we enthusiastically welcome newcomers.
Please join the live stream on time to ensure you don't miss any beginner-focused insights.
Have your laptop, and prepare for this hands-on learning experience.
No prior knowledge is required; we'll guide you from the beginning.
Create a GitHub account

Our event link will be shared exclusively within our welcoming Discord community, which is the perfect place for beginners like you to connect and learn together. Join us there to access the workshop and embark on your open-source journey.

Virtual Workshop on Low-Code Contributions for Hacktoberfest - Perfect for Beginners!

Abhay — Fri, 06 Oct 2023 06:21:30 +0000

Event Details:

Date: 8 October 2023
Day: Sunday
Time: 11 AM
Platform: Discord

What will be covered in the event :

What is hacktoberfest and open-source?
How to register and successfully complete Hacktoberfest ?
Why contribute to open source?
Git GitHub basic and first contribution
How to make low code contributions to our repo

Important Things to Note:

This event is tailored for beginners, and we enthusiastically welcome newcomers.
Please join the live stream on time to ensure you don't miss any beginner-focused insights.
Have your laptop, and prepare for this hands-on learning experience.
No prior knowledge is required; we'll guide you from the beginning.
Create a GitHub account

Hacktoberfest 2023 Pledge

Abhay — Mon, 02 Oct 2023 09:35:50 +0000

My Pledge
I pledge to be welcoming, helpful contributing, and adding to world and interweb love. I am looking forward to constructing and developing. I will be Including myself and others for a better community in learning and teaching.