DEV Community: Kanishka Shrivastava

#beginners #sql #machinelearning #100daysofcode

Kanishka Shrivastava — Wed, 15 Apr 2026 15:21:04 +0000

Apr 15, 2026 · Day 4 of 30

Day 4: I wrote my first SQL queries today and suddenly data feels a lot more accessible

I took a small detour from Python today but an important one. I wrote my very first SQL queries.

I know what you might be thinking: isn't this an ML journey? Yes. But data for ML has to come from somewhere. And a lot of the time, that somewhere is a database you query with SQL. So this felt like the right moment to start.

Starting from zero

I had never written a SQL query before today. Not even a simple one. I knew the word "database" and that SQL was how you talked to it that was the full extent of my knowledge going in.

I started with the three most fundamental keywords: SELECT, FROM, and WHERE. And honestly? Within about 20 minutes, I felt like I could actually read data.

SELECT name, age FROM users WHERE age > 25;

That query just clicked immediately. You're saying: give me the name and age columns, from the users table, but only rows where age is greater than 25. It reads almost like plain English.

The moment it connected to ML

I kept thinking back to the Titanic dataset from Day 3. What if that data lived in a database instead of a CSV? I could query exactly the rows I needed say, only passengers in third class before even loading them into Pandas.

SQL isn't separate from ML. It's often the first step getting the right data out before you do anything with it. That realisation made today feel very worth it.
What the three keywords actually do

SELECT tells the database which columns you want. FROM tells it which table to look in. WHERE filters the rows based on a condition. Together, those three cover a huge amount of real-world data work.

SELECT survived, pclass, age FROM titanic WHERE pclass = 1;

I wrote that imagining the Titanic data in a database. First class passengers only. Three columns. Clean and specific. That's the power of SQL you don't have to load everything and filter in Python. You ask for exactly what you need.

What's next

I want to go deeper GROUP BY, COUNT, joins between tables. But today was about getting comfortable with the basics, and I feel good about where I landed.

Four days in and the pieces are starting to connect in ways I didn't expect when I started.

QUESTION FOR YOU

How important has SQL been in your ML or data work day to day? Is it something I should go deeper on early, or just know the basics and move on?

#beginners #machinelearning #pandas #kaggle

Kanishka Shrivastava — Tue, 14 Apr 2026 13:20:27 +0000

Apr 14, 2026 · Day 3 of 30

Day 3: I explored the Titanic and Iris datasets the code was easy, understanding the data was not

Today I worked with real datasets for the first time the Titanic and Iris datasets from Kaggle. Loading them, exploring them, filtering columns, even making a few basic visualizations. The tools worked. Pandas did what it was supposed to do.

But somewhere in the middle I hit something I didn't expect: I had no idea what I was actually looking at.

Two very different datasets

Titanic

Passenger data age, class, fare, survived or not. Real people, real event. Messy, missing values everywhere.

Iris

Flower measurements petal length, sepal width, species. Clean, tidy, almost too perfect. A classic beginner dataset for a reason.

What I did

I started with the basics — loading the CSV, running .head(), .info(), and .describe() to get a feel for the shape of the data. Then I filtered some columns, looked at value counts, and made a couple of simple plots.

import pandas as pd df = pd.read_csv("titanic.csv") print(df.head()) print(df.describe()) print(df["Survived"].value_counts())

Technically, all of this worked fine. The output printed, the charts showed up. But then I stopped and asked myself okay, what does this actually tell me?

The part nobody warns you about

I could see that the Pclass column had values 1, 2, and 3. I had to look up that those are ticket classes first, second, third. I could see SibSp and had no idea what it meant without reading the documentation (siblings and spouses on board, apparently).

The code was easy. Understanding what the numbers represent and why it matters for prediction that was the actual challenge of today.

With Iris it was simpler flowers, measurements, species. That clicked faster. But Titanic taught me something important: before you model anything, you have to understand the story the data is trying to tell.

What I'm taking into Day 4

I want to slow down on Titanic a bit more specifically look at which columns might actually predict survival, and why. Not training a model yet. Just thinking about the data like a human before handing it to a machine.

I think that mindset shift from "run the code" to "understand the data" might be one of the most important early lessons in ML.

QUESTION FOR YOU

When you first worked with the Titanic dataset what was the column or insight that made you go "oh, this is what ML is actually about"?

#beginners #machinelearning #numpy #pandas

Kanishka Shrivastava — Mon, 13 Apr 2026 15:32:47 +0000

Apr 13, 2026 · Day 2 of 30

Day 2: I met NumPy and Pandas today here's what actually made sense

Yesterday I committed to learning AI/ML in public. Today I did the first real thing I opened Python and started looking at the two libraries everyone mentions when talking about ML: NumPy and Pandas.

No model training yet. No fancy algorithms. Just getting comfortable with the tools that sit underneath all of it.

Why these two first?

From everything I've read, you can't really do ML without understanding how data is stored and manipulated. NumPy and Pandas are how that happens in Python. So before I touch any ML library, I want these to feel natural.

NumPy

Works with numbers at speed. Think of it as Python lists but way faster and built for math operations on large datasets.

Pandas

Works with tables of data. Like Excel but in Python rows, columns, filters, and a lot more control.

What I actually tried

I started with NumPy arrays creating them, doing basic operations, understanding why they exist when Python already has lists. The speed and simplicity of doing math on an entire array at once was the thing that clicked for me:

import numpy as np arr = np.array([10, 20, 30, 40, 50]) print(arr * 2) # Output: [20 40 60 80 100]

With regular Python you'd need a loop for that. With NumPy it's one line. That's when I understood why ML uses it you're constantly doing operations on thousands of numbers at once.

Then I moved to Pandas. I created a small DataFrame just to see how it feels:

import pandas as pd data = {"name": ["Alice", "Bob", "Kanishka"], "score": [88, 92, 79]} df = pd.DataFrame(data) print(df)

The moment the table printed cleanly in my terminal rows, columns, index — something about it felt satisfying. This is what real data will look like.
What still confuses me

Pandas has a lot of methods. A lot. I kept seeing things like .iloc, .loc, .groupby and I didn't go deep on any of them yet. That's tomorrow's problem. Today I just wanted to get comfortable with the shape of things.

One thing I'd tell Day 1 me

Don't try to memorise the methods. Just run the code, see the output, understand what changed. The rest comes with repetition.

QUESTION FOR YOU

Is there a Pandas or NumPy trick you wish someone had shown you early on? I'm at the very beginning genuinely curious what matters most.

#beginners #machinelearning #100daysofcode #journey

Kanishka Shrivastava — Sun, 12 Apr 2026 12:14:25 +0000

Apr 12, 2026 · Day 1 of 30

Day 1: I'm diving into AI/ML no roadmap, just curiosity and daily commitment

AI is everywhere right now in the tools I use, the products I read about, the conversations I have with other developers. And I realised I want to go deeper than just using it. I want to understand how it actually works.

So today is Day 1. I'm starting my AI/ML learning journey in public, one post at a time.

Where I'm starting from

I know Python basics enough to be comfortable, not enough to feel like an expert. I've never trained a model or worked with real data in any serious way. That's exactly the starting point I want to document, because I think a lot of people are here too.

The plan: 15 minutes of learning every day. One honest post about what I explored, what I understood, and what still confuses me. 30 days, no skipping.
Why I'm doing this publicly

Writing forces me to actually understand something rather than just skim it. And sharing it means someone can point out when I've got it wrong which is honestly just as valuable as getting it right.

I'm not sure yet whether I'll end up most interested in NLP, computer vision, data science, or something else entirely. Part of what makes this exciting is that I genuinely don't know where it leads. I'm going to let the learning point the way.

What's coming next

Tomorrow I'll start with the actual fundamentals what machine learning is, how it differs from regular programming, and why that distinction matters. Small steps, but real ones.

If you're learning AI/ML too at any stage I'd love to have you follow along. And if you're further ahead, I'm all ears.

QUESTION FOR YOU

What's one resource a course, a book, a project idea that you'd recommend to someone starting AI/ML from scratch today?

#java #datastructures #programming #collections

Kanishka Shrivastava — Fri, 06 Mar 2026 12:09:48 +0000

Java Concepts I’m Mastering – Part 13: HashMap in Java (Key-Value Data Storage)

Continuing my journey of mastering Java fundamentals.

Today’s concept: HashMap — a powerful way to store and access data using key-value pairs.

What is a HashMap?

A HashMap stores data in the form of:

Key → Value

Each key is unique and maps to a specific value.

Example:

"Java" → 1995
"Python" → 1991
Creating a HashMap

import java.util.HashMap;

HashMap<String, Integer> languages = new HashMap<>();

languages.put("Java", 1995);
languages.put("Python", 1991);
languages.put("C++", 1985);
Accessing Values
System.out.println(languages.get("Java"));

Output:

Useful HashMap Methods

languages.put("Go", 2009);     // add element
languages.get("Python");       // access value
languages.remove("C++");       // delete element
languages.containsKey("Java"); // check key
languages.size();              // total elements

Why HashMap is Powerful

Very fast lookups

Stores structured data

Used heavily in real applications

Examples:

Caching systems

Database indexing

Counting frequencies

What I Learned

HashMap stores unique keys with values

Lookup operations are extremely fast

It's one of the most important structures in Java

Understanding HashMap is essential for efficient programming.

Next in the series: Java Streams API (Modern Data Processing)

#java #collections #programming #datastructures

Kanishka Shrivastava — Thu, 05 Mar 2026 12:19:39 +0000

Java Concepts I’m Mastering – Part 12: ArrayList vs LinkedList

Continuing my journey of mastering Java fundamentals.

Today’s concept: ArrayList vs LinkedList — two important classes from the Java Collections Framework.

Both store collections of elements, but they work differently internally.

ArrayList

ArrayList is backed by a dynamic array.

import java.util.ArrayList;

ArrayList<String> list = new ArrayList<>();
list.add("Java");
list.add("Python");

Best for:

Fast random access

Reading data frequently

Limitation:

Inserting or deleting elements in the middle can be slower.

LinkedList

LinkedList is implemented using nodes connected by pointers.

import java.util.LinkedList;

LinkedList<String> list = new LinkedList<>();
list.add("Java");
list.add("Python");

Best for:

Frequent insertions and deletions

Working with queues or stacks

Limitation:

Accessing elements by index is slower.

Key Difference
ArrayList LinkedList
Dynamic array Doubly linked list
Faster access Slower access
Slower insert/delete Faster insert/delete

What I Learned

Use ArrayList for fast data access.

Use LinkedList when modifying data frequently.

Understanding data structures helps write efficient programs.

Next in the series: HashMap in Java (Key-Value Data Storage)

#java #exceptions #programming #backend

Kanishka Shrivastava — Wed, 04 Mar 2026 08:40:37 +0000

Java Concepts I’m Mastering – Part 11: Exception Handling (try-catch-finally)

Continuing my journey of mastering Java fundamentals.

Today’s concept: Exception Handling — because real programs must handle errors gracefully.

What is an Exception?

An exception is:

An unexpected event that disrupts normal program flow.

Examples:

Dividing by zero

Accessing invalid array index

Reading a missing file

If not handled → program crashes.

try-catch Block

We use try to write risky code
and catch to handle errors.

try {
    int result = 10 / 0;
} catch (ArithmeticException e) {
    System.out.println("Cannot divide by zero!");
}

Instead of crashing, it prints a message.

finally Block

The finally block:

Always executes

Used for cleanup (closing files, DB connections, etc.)


try {
    System.out.println("Trying...");
} catch (Exception e) {
    System.out.println("Error occurred");
} finally {
    System.out.println("This always runs");
}

Types of Exceptions

Checked Exceptions (compile-time)

Must be handled

Example: IOException

Unchecked Exceptions (runtime)

Occur during execution

Example: NullPointerException

Why It’s Important

Prevents program crashes

Improves reliability

Makes applications production-ready

Good developers don’t just write logic —
they handle failure properly.

What I Learned

Always handle predictable errors

Use specific exceptions instead of generic ones

Clean up resources using finally

Exception handling separates beginners from professionals.

Next in the series: Collections Framework in Java (ArrayList vs LinkedList)

#devchallenge #geminireflections #gemini #ai #productivity

Kanishka Shrivastava — Tue, 03 Mar 2026 09:34:37 +0000

What I Built with Google Gemini

I created “AI Code Companion”, a tool designed to help developers write, debug, and optimize code faster. The idea came from my own experience struggling to troubleshoot errors late at night during hackathons.

Using Google Gemini, the AI could:

Suggest solutions to bugs in real time.

Offer optimized alternatives for inefficient code.

Explain complex concepts in simple terms.

Gemini’s natural language understanding made it possible to interact with the AI conversationally, almost like having a coding mentor available 24/7.

What I Learned

This project was a crash course in practical AI integration:

Technical: Learned to handle API calls efficiently, parse AI responses, and create a seamless user interface.

Soft Skills: Patience, iterative design, and translating user feedback into functional improvements.

Unexpected Lessons: Even the smartest AI can be unclear without the right prompts. Crafting precise questions drastically improves the usefulness of the output.

Most importantly, I realized how AI can augment human learning and productivity, rather than just automate tasks.

Google Gemini Feedback

What Worked Well: Gemini’s responses were fast, contextually relevant, and easy to integrate into my desktop workflow.

Where I Struggled: For very niche coding scenarios, outputs could be too generic, requiring me to experiment with prompt phrasing.

Overall: The experience reaffirmed Gemini’s potential as a developer’s collaborative AI, and I’m excited to explore more complex use cases in the future.

Looking Forward

Next, I aim to:

Build team collaboration features so multiple developers can consult the AI simultaneously.

Expand the AI’s multi-language support for cross-platform development.

Explore integration with GitHub to suggest code improvements directly in pull requests.

This project has shown me the practical power of AI in real-world development, and I’m motivated to continue experimenting with Google Gemini to make coding faster, smarter, and more intuitive.

#java #oop #programming #100daysofcode

Kanishka Shrivastava — Tue, 03 Mar 2026 09:23:58 +0000

Java Concepts I’m Mastering – Part 10: The final Keyword in Java

Continuing my journey of mastering Java fundamentals.

Today’s concept: The final keyword — small word, strong restrictions.

final is used to prevent modification.

But its behavior depends on where it’s applied.

Final Variable

A final variable cannot be reassigned.


final int MAX_AGE = 100;

// MAX_AGE = 120; // Error

Once assigned → value cannot change.

If it's a reference variable:

final List<String> list = new ArrayList<>();
list.add("Java");   // Allowed
// list = new ArrayList<>(); // Not allowed

You cannot change the reference,
but you can modify the object.

Final Method

A final method cannot be overridden.

class Animal {
    final void sound() {
        System.out.println("Animal sound");
    }
}

Child classes cannot modify this behavior.

Final Class

A final class cannot be inherited.


final class Utility {
    void print() {
        System.out.println("Utility class");
    }
}

No class can extend Utility.

Why It’s Important

Improves security

Prevents unwanted modification

Helps in writing immutable classes

Used heavily in system-level and framework code

What I Learned

final protects design decisions

Use it intentionally, not randomly

It strengthens object-oriented design

Small keyword. Big control.

Next in the series: Exception Handling in Java (try-catch-finally)

#java #springboot #backend #ai or #webdev

Kanishka Shrivastava — Sun, 01 Mar 2026 13:28:58 +0000

Let’s Connect!

LinkedIn: https://www.linkedin.com/in/kanishka-shrivastava-496785336

GitHub: https://github.com/KanishkaShrivastava07

Always open to collaborations, learning, and exciting projects

#java #oop #inheritance #programming

Kanishka Shrivastava — Sun, 01 Mar 2026 13:17:44 +0000

Java Concepts I’m Mastering – Part 9: Inheritance in Java (extends Keyword)

Continuing my journey of mastering Java fundamentals.

Today’s focus: Inheritance — the mechanism that allows one class to acquire properties and behavior of another class.

What is Inheritance?

Inheritance means:

A child class can reuse the fields and methods of a parent class.

This promotes:

Code reusability

Clean hierarchy

Logical relationships

Syntax


class ChildClass extends ParentClass {
    // additional features
}

Example

class Animal {
    void eat() {
        System.out.println("This animal eats food");
    }
}

class Dog extends Animal {
    void bark() {
        System.out.println("Dog barks");
    }
}

Now:

Dog d = new Dog();
d.eat();   // inherited
d.bark();  // own method

The Dog class reuses behavior from Animal.

Types of Inheritance in Java

Single

Multilevel

Hierarchical

(Java does not support multiple inheritance with classes — but it does through interfaces.)

Why It Matters

Inheritance helps in:

Building scalable systems

Reducing code duplication

Implementing runtime polymorphism

It works closely with method overriding, which I covered earlier in this series.

What I Learned

Use inheritance for “is-a” relationships

Avoid unnecessary deep hierarchies

Combine with abstraction for clean design

Inheritance is a core building block of object-oriented design.

Next in the series: Final Keyword in Java (final variable, method, class)

#devchallenge #weekendchallenge #showdev

Kanishka Shrivastava — Sat, 28 Feb 2026 09:36:24 +0000

ExamMate AI 🚀

Smart Crash Planner for Engineering Students

This is a submission for the DEV Weekend Challenge: Community

🚨 The Problem

Every engineering student knows this moment:

The exam timetable gets announced.

You open the syllabus.

It’s huge.

And you think:

“Where do I even start?”

As part of this community myself, I’ve experienced the stress, confusion, and last-minute panic that comes with technical subjects and limited time.

Engineering students don’t just need motivation.

We need structure.

👩‍💻 The Community

I built this project for engineering students — a high-pressure academic community constantly balancing:

Dense technical syllabi
Multiple exams in a short window
Weak topics that need extra attention
Last-minute crash preparation

This tool is designed to make exam prep feel manageable instead of overwhelming.

🧠 What I Built

I created ExamMate AI, a lightweight AI-inspired crash planner that:

📅 Generates personalized day-wise study plans
⏳ Automatically calculates days left until the exam
🎯 Distributes weak topics intelligently
🚨 Activates Panic Mode when ≤ 3 days remain
✅ Tracks daily progress with checkboxes
📊 Displays a dynamic progress bar
🌙 Includes Light/Dark mode toggle
🤖 Simulates an AI “Analyzing…” experience

The goal:

Turn panic into a plan.

No login.

No backend.

No friction.

Just clarity and focus.

🔥 Demo

🌐 Live App:

https://kanishkashr07.github.io/ExamMate-AI/

📸 Preview:

💻 Code

GitHub Repository:

https://github.com/kanishkashr07/ExamMate-AI

The entire project is built as a clean, single-page frontend application for simplicity and accessibility.

⚙️ How I Built It

This project was built using:

HTML5 — Semantic structure
CSS3 — Responsive design + dark/light theming
Vanilla JavaScript —
- Date calculations
- Dynamic schedule generation
- Panic Mode logic
- Progress tracking
- Interactive UI updates

No frameworks.

No libraries.

Just core web technologies.

I intentionally kept it simple to demonstrate that impactful tools for communities can be built without heavy infrastructure.

💡 Why This Matters

This isn’t just a challenge submission.

It’s a solution to a real problem I face as a student.

Community-driven development means building for people whose struggles you genuinely understand.

ExamMate AI is my attempt to make exam season just a little less stressful for engineering students everywhere.

Thank you DEV for hosting this challenge 🙌

I’m excited to continue improving ExamMate AI into a smarter academic companion.