Forem: Soumyadeep Dey

I built a fully interactive 3D Solar System you can explore right from your browser.

Soumyadeep Dey — Sat, 16 Aug 2025 13:55:40 +0000

🪐 Explore the Cosmos from Your Browser

I’m stoked to share my recent project: 3D Solar System Simulation, crafted with Three.js and accelerated with Vite! Tap into the wonders of our cosmic neighborhood through your screen—no telescopes needed.

🔗 Check out the live project below:

https://3d-solar-system-three-js.vercel.app/

📸 Gallery Snapshot

💡 Why I Built It

To visualize planetary orbits, rotations, and atmospheres in real-time
To flex the power of Three.js combined with modern tooling like Vite
To experiment with interactive controls and responsive design
To have a fun showcase for learning and collaboration

🚀 Project Highlights

Realistic 3D models of the Sun, planets, dwarf planets, and moons
Smooth orbit animations combined with planet rotations
Scaled visuals for better clarity and navigation
Full interaction via mouse: orbit, zoom, and pan
Modern tooling with Vite for blazing-fast development
Mobile-friendly interface with responsive scaling

🛠 Behind the Scenes

3d-Solar-System-ThreeJS/
├── public/
│   └── textures/             # Planet & celestial textures
├── src/
│   ├── main.js               # Core rendering logic
│   └── additional modules... # Planet classes, UI controls, etc.
├── index.html
├── package.json
├── vite.config.js
└── README.md

⚡ Installation & Local Run

Clone and run locally:

git clone https://github.com/SoumyaEXE/3d-Solar-System-ThreeJS.git
cd 3d-solar-system-three-js
npm install
npm run dev

Then visit

http://localhost:5173

To build a production version:

npm run build

📚 What I Learned

Skill	Takeaway
Three.js fundamentals	Scene setup, camera controls, mesh rendering
Animation techniques	Smooth orbits & rotations using `requestAnimationFrame`
Performance tuning	Optimized for smoother animations with Vite
Responsive design	UI/UIX that works seamlessly across devices

🌌 Join the Journey

I’d love your thoughts! Let me know:

What features you’d like added next
How the scaling feels on mobile
Any performance hiccups you spotted

Don’t forget to ⭐ the repo if you enjoy the simulation — and open an issue or PR if you want to contribute!

🔗 Related Projects & Resources

Three.js Examples — official showcase
Three.js Documentation — API deep dive
Vite — next-gen frontend tooling

Thanks for exploring with me!
— Soumya

What Is Vibe Coding? How To Do It In 2025

Soumyadeep Dey — Sat, 12 Jul 2025 07:00:25 +0000

🧑‍💻 Follow me on GitHub for more experiments, tools, and guides: github.com/SoumyaEXE

What if you could skip the boilerplate and just say what you want your app to do?

That’s vibe coding—a 2025 workflow where you build web apps, prototypes, and backend APIs using plain English. Whether you’re a pro developer tired of repetitive tasks or a beginner with big ideas, vibe coding changes how you ship.

This article breaks down what vibe coding is, how it works, tools to try, and how GitHub plays a major role in your AI-powered workflow.

🔍 What Is Vibe Coding?

Vibe coding is building software by describing your app, component, or logic in natural language. Tools like Cursor, Claude Code, or Replit AI translate your intent into code. GitHub Copilot and Vercel’s AI SDKs are integrating this even deeper into production-ready workflows.

🧠 “The hottest new programming language is English.” — Andrej Karpathy

Vibe coding isn't just code generation—it's iteration + intention + automation.

⚡ Why Developers (and Non-Devs) Love It

🧑‍🎓 Beginners: Build apps with zero syntax knowledge
💼 Professionals: Skip boilerplate, test logic fast
⏱️ Everyone: Launch MVPs in hours, not weeks

🛠️ Tools for Vibe Coding in 2025

Tool	What it’s good for	GitHub Integration
Cursor	Code generation in VS Code	✅ Commits + Copilot sync
Claude Code	Complex structured logic via prompts	❌ Manual export
Replit AI	Full-stack in-browser development	✅ GitHub sync
Vercel AI SDK	Integrate AI responses in Next.js apps	✅ Native
Postman AI	API testing & backend autogen	✅ Push collections

Want GitHub commits that make sense? Cursor and Replit are great for AI-generated commits, clean histories, and Copilot X preview features.

✍️ How to Vibe Code

1. Write Specific Prompts

Bad:

Make a website

Good:

Build a dark-themed Next.js blog with a subscribe form and Markdown support.

Even better:

Create a TypeScript-based Next.js 14 app with Tailwind CSS. Add a newsletter form using Vercel’s Edge Functions and connect to a Notion DB.

2. Test, Commit, Repeat

Once the tool generates the code:

Run locally (npm run dev)
Test features and endpoints
Fix bugs via prompts
Auto-commit to GitHub

git add .
git commit -m "✨ AI-generated landing page with Tailwind and form handling"
git push

AI even suggests commits now. Just review and approve.

3. Use GitHub for Versioning + Deploying

Every good AI project needs version control. Here's a simple Vercel-integrated flow:

vercel init
vercel --prod

Want preview links after every push? GitHub Actions + Vercel CI does it for you.

🚨 Pitfalls to Avoid

Problem	Fix
Vague prompts	Be specific with structure + tech
Wrong framework	Always mention your stack
Code doesn't run	Use Replit or local dev server
AI bloats the code	Refactor manually or with Copilot
Debugging is messy	Break into smaller prompts

🧪 Example Vibe Prompt (Backend + DB)

“Create an Express.js REST API with a /books route, connect it to a SQLite DB, and deploy it with Vercel Serverless Functions.”

⬇️ AI Output:

/api/books.js with CRUD routes
db.sqlite pre-seeded with sample data
vercel.json configured
.env support added

All ready to deploy + preview live via GitHub commits.

🔮 What’s Next?

AI-driven workflows are becoming GitHub-native.

Copilot Workspace is in preview
GitHub Actions trigger based on AI-generated code
aidd.io is launching something major on July 15, 2025

Get ready for AI-powered commit messages, automated PR descriptions, and test coverage reports—all from natural language.

💬 Final Thoughts

Vibe coding is a real shift in how we build. You still need logic and structure, but AI handles the scaffolding.

✅ Start small

✅ Be specific

✅ Use GitHub for backup and versioning

✅ Iterate fast

Want to ship ideas without the grind? Vibe coding might be your new workflow.

🔗 Stay in the Loop

Follow me on GitHub: SoumyaEXE
Leave a ❤️ if you vibe with this
Share your AI-generated repos in the comments!

See you on the other side of the commit log 🚀

Top 10 Must-Know GitHub Repositories for Backend Developers (2025) 🔥

Soumyadeep Dey — Sat, 12 Jul 2025 06:43:05 +0000

As a backend developer, mastering the right tools and libraries can significantly improve your workflow, scalability, and project maintainability. Here’s a concise list of 10 highly useful GitHub repositories tailored for backend developers in 2025.

1. expressjs/express

Minimalist Web Framework for Node.js

Express is a fast, unopinionated, and widely-used web framework for building APIs and server-side applications.

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

app.get('/', (req, res) => {
  res.send('Hello Backend World!');
});

app.listen(3000, () => console.log('Server running'));

✅ Lightweight and flexible
✅ Robust routing
✅ Middleware support

2. typeorm/typeorm

ORM for TypeScript and JavaScript

TypeORM allows you to interact with SQL databases using an object-oriented approach.

@Entity()
export class User {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;
}

✅ Supports multiple DB engines (PostgreSQL, MySQL, etc.)
✅ Migration and CLI support
✅ Decorator-based modeling

3. prisma/prisma

Next-Generation Type-Safe ORM

Prisma offers a powerful and type-safe interface for querying your database using auto-generated TypeScript types.

model User {
  id    Int     @id @default(autoincrement())
  email String  @unique
  posts Post[]
}

✅ Type safety for queries
✅ Built-in migrations
✅ Great developer experience

4. nestjs/nest

Progressive Framework for Building Scalable Server-Side Apps

NestJS uses modern JavaScript, TypeScript, and modular architecture inspired by Angular.

@Controller('users')
export class UsersController {
  @Get()
  findAll(): string {
    return 'This returns all users';
  }
}

✅ Dependency injection
✅ Modular architecture
✅ Ideal for microservices and enterprise apps

5. docker/awesome-compose

Collection of Docker Compose Examples

This repository provides practical and production-ready Docker Compose templates.

services:
  backend:
    build: .
    ports:
      - 3000:3000
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

✅ Quick environment setup
✅ Great for learning and deployment
✅ Covers common backend stacks

6. sql-js/sql.js

SQLite Compiled to JavaScript

SQL.js allows you to run a full SQLite database in the browser or Node.js.

const SQL = require('sql.js');
const db = new SQL.Database();
db.run("CREATE TABLE test (col1, col2);");

✅ No external dependencies
✅ Perfect for testing and learning SQL
✅ Use in web apps or sandboxed environments

7. kamranahmedse/developer-roadmap

Visual Learning Path for Developers

This roadmap outlines the core skills and technologies needed to become a backend developer.

✅ Covers languages, tools, protocols, DBs
✅ Updated regularly
✅ Community-driven and beginner-friendly

8. elastic/elasticsearch

Search and Analytics Engine

Elasticsearch is used for full-text search, data analysis, logging, and monitoring.

curl -X GET "localhost:9200/_cat/indices?v"

✅ Distributed and scalable
✅ Powerful querying and filtering
✅ Widely used with Logstash, Kibana

9. auth0/node-jsonwebtoken

JWT Authentication for Node.js

A simple and robust library for creating and verifying JSON Web Tokens.

const jwt = require('jsonwebtoken');
const token = jwt.sign({ userId: 123 }, 'your-secret', { expiresIn: '1h' });

✅ Stateless authentication
✅ Supports expiration and claims
✅ Easy to integrate into APIs

10. fastify/fastify

High-Performance Node.js Web Framework

Fastify is designed for high throughput and low overhead.

const fastify = require('fastify')();

fastify.get('/', async (request, reply) => {
  return { hello: 'world' };
});

fastify.listen({ port: 3000 });

✅ Schema-based validation
✅ Highly extensible plugin system
✅ Blazing fast performance

✅ Final Thoughts

These repositories are more than just popular — they provide the backbone for robust, scalable, and efficient backend development.

Use Express or Fastify for APIs
Manage data using Prisma or TypeORM
Secure your backend with JWT
Containerize with Docker
Monitor with Elasticsearch

Explore these repos, contribute to them, and use them in real-world projects to become a more effective backend developer in 2025.

📌 Stay Connected

Follow me on GitHub
Bookmark this article for reference
Leave a ❤️ if you found it helpful

Happy building! 🚀

What's the most challenging coding problem you've encountered, and how did you overcome it? 😮

Soumyadeep Dey — Sun, 03 Sep 2023 14:42:25 +0000

So What Was The Biggest Problem You've Encountered While Doing Coding? 😶

Let Everybody Know In Comments! 🤔❤

(Hit a Follow To Me ~ Its a Small Promotion 🤣✋🏻)

Jokeday Funday: Part 6 - More Programming Humor to Brighten Your Day

Soumyadeep Dey — Sun, 03 Sep 2023 14:36:53 +0000

Jokeday Funday: Part 6 - More Programming Humor to Brighten Your Day

Joke 1: The Broken Monitor

Why did the programmer go broke?

Because they used up all their cache and couldn't find their cache flow!

Joke 2: The Time Traveler

Why did the developer bring a ladder to the bar?

Because they wanted to reach the "root" beer on the top shelf!

Joke 3: The Coding Detective

Why did the programmer always carry a pencil and paper?

Because you never know when you'll need to draw a "byte" sketch of a suspect!

Joke 4: The Bug Whispers

Why did the developer become a gardener?

Because they had a talent for making bugs flourish!

Joke 5: The Tech Support Hero

Why did the tech support agent go to therapy?

Because they couldn't stop hearing voices saying, "Have you tried turning it off and on again?"

Joke 6: The Password Blues

Why did the password go to therapy?

Because it had too many issues to "hash" out!

Joke 7: The Agile Athlete

Why did the developer start running marathons?

Because they wanted to master the art of sprinting and releasing!

Joke 8: The Code Poet

Why did the developer start writing poetry?

Because they realized code comments could be a form of art!

Joke 9: The Lost Pointer

Why did the pointer go on vacation?

Because it needed to refresh its memory!

Joke 10: The Debugging Zen

Why did the programmer become a meditation guru?

Because they wanted to find inner peace and tranquility amidst runtime errors!

Bonus Joke: The Coding Conductor

Why did Soumya become a programmer?

Because he wanted to orchestrate the symphony of logic and create beautiful software symphonies!

What programming languages are you most comfortable or skilled with? 🤔

Soumyadeep Dey — Sat, 02 Sep 2023 14:58:59 +0000

Say Me In Comments!

What are those languages you are skilled with...

🤔💬

What Inspired You To Became A Coder? 🤔

Soumyadeep Dey — Wed, 30 Aug 2023 18:31:53 +0000

Share your dev journey in the comments!

Let me know, your journey will inspire us too!

Jokeday Funday: Part 5 - More Hilarious Programming Jokes

Soumyadeep Dey — Sun, 27 Aug 2023 18:43:38 +0000

Jokeday Funday: Part 5 - More Hilarious Programming Jokes

Joke 1: The Code Chef

Why did the programmer go to cooking school?

To learn how to make exceptional "byte"-sized dishes!

Joke 2: The Unbreakable Code

Why did the computer program go to therapy?

It had too many unresolved issues and couldn't "function" properly!

Joke 3: The Copy-Paste Dilemma

Why did the programmer get kicked out of the art class?

Because they kept using "Ctrl+C" and "Ctrl+V" to copy-paste the drawings!

Joke 4: The Dancing Developer

Why did the developer refuse to dance?

Because they couldn't find the right "move" statement in the dance routine!

Joke 5: The Coding Astronaut

Why did the astronaut become a programmer?

To explore the vast universe of coding and debug alien technology!

Joke 6: The Music of Errors

Why did the developer start a band?

Because they wanted to create a symphony of "404" error sounds!

Joke 7: The Database's Secret

Why did the database break up with the server?

Because it caught the server cheating with too many queries!

Joke 8: The Coffee-Driven Code

Why did the programmer give up coffee?

Because it made their code jittery and full of "bean" errors!

Joke 9: The Sleepless Coder

Why did the developer sleep with their laptop?

Because they heard the laptop's "Zzz" sound was the best lullaby for coders!

Joke 10: The Quantum Programming

Why did the quantum programmer get frustrated?

Because they couldn't debug a bug that was both there and not there at the same time!

Bonus Joke: The Debugging Mastermind

Why did Soumya become a programmer?

Because she wanted to outsmart bugs and teach computers a thing or two about logic!

Master The Art Of Code Documentation In 5 Minutes

Soumyadeep Dey — Tue, 15 Aug 2023 15:32:15 +0000

Code Documentation Importance

Code documentation is a crucial aspect of software development that often doesn't receive the attention it deserves. It's not just about writing comments – it's about creating a comprehensive and easily understandable narrative for your codebase. In this article, we will delve into the world of code documentation, exploring its importance, best practices, and tools that can help you become a documentation maestro.

1. Why Code Documentation Matters

Effective code documentation serves as a bridge between developers, making it easier to understand and maintain code. It helps onboard new team members, fosters collaboration, and minimizes misunderstandings. Properly documented code is also essential for long-term maintenance and debugging.

2. Choosing the Right Documentation Approach

Different projects may require different levels of documentation. From inline comments to high-level overviews, finding the right balance is key. Strive for clarity and consistency in your documentation style throughout the project.

3. The Anatomy of Well-Documented Code

Inline Comments: Explain complex logic, assumptions, or edge cases directly within the code.
Function and Method Documentation: Clearly define the purpose, parameters, return values, and possible exceptions.
High-Level Overviews: Provide a roadmap of the project's architecture, design decisions, and key components.
Tutorials and Examples: Showcase how to use your code through practical examples and step-by-step guides.
Change Logs: Document significant updates, bug fixes, and improvements to help users and collaborators stay informed.

4. Best Practices for Effective Documentation

Keep It Simple: Use clear and concise language. Avoid jargon and technical terms unless necessary.
Stay Up-to-Date: Regularly update your documentation to reflect changes in the codebase.
Use a Consistent Format: Choose a standard formatting style for code snippets, headers, and sections.
Document Assumptions: Explicitly state any assumptions your code makes about its environment or inputs.
Address 'Why,' Not Just 'How': Explain the rationale behind design decisions and code choices.

5. Tools to Elevate Your Documentation Game

Javadoc and Doxygen: Generate API documentation from code comments in Java and C++ respectively.
Sphinx: Create documentation for Python projects, complete with tutorials and examples.
Markdown and Readme Files: Craft well-structured documentation using lightweight markup languages.
Diagramming Tools: Visualize architecture, flowcharts, and diagrams for better comprehension.
Version Control Integration: Leverage tools like Git to manage documentation changes along with code changes.

6. Documentation in Agile and Continuous Integration

In an Agile development environment, documentation should evolve alongside code changes. Incorporate documentation tasks into your sprints and consider them part of the development process. Automated documentation generation can be integrated into your continuous integration workflow.

Conclusion

Mastering the art of code documentation is a skill that separates good developers from great ones. By prioritizing clear, concise, and comprehensive documentation, you empower your team and contribute to the longevity and success of your projects. Remember, documentation is not just a chore – it's a powerful tool that amplifies the impact of your code.

So, embrace the role of a documentation maestro and watch your codebase flourish with understanding and collaboration.

Useful Resources

Jokeday Funday Part #4

Soumyadeep Dey — Sun, 30 Jul 2023 01:35:29 +0000

Jokeday Funday: Part 4 - More Programming Jokes to Make Your Day

Joke 1: The Lazy Developer

Why do programmers prefer to work in shortcuts?

Because they believe in optimizing their efforts for maximum laziness!

Joke 2: The Unseen Error

Why do programmers always look frustrated while reading code?

Because they are searching for an error that seems to be hiding from them!

Joke 3: The Ancient Codebase

Why did the archaeologist become a programmer?

To dig through ancient code and decipher the secrets of the past!

Joke 4: The Code Translator

Why do programmers make good linguists?

Because they know how to speak in multiple programming languages!

Joke 5: The Mysterious Email

Why did the developer's email always go to the spam folder?

Because it had a suspicious attachment - an "exe" file named "LoveLetter"!

Joke 6: The Restaurant Error

Why did the programmer go hungry at the restaurant?

Because their fork was stuck in an infinite loop with the spaghetti!

Joke 7: The Parallel Universe Revisited

Why do programmers believe time travel is possible?

Because they often encounter versions of their code from the past and future!

Joke 8: The Alien Encounter

Why did the alien refuse to talk to the programmer?

Because they didn't understand the programmer's strange language - "Code"!

Joke 9: The Web Developer's Pun

Why did the web developer break up with their internet connection?

It had too many "lags" in the relationship!

Joke 10: The Algorithm's Complaint

Why do algorithms hate visiting art museums?

Because they can't stand all the "abstract" art!

Bonus Joke: The Inquisitive Coder

Why did Soumya become a programmer?

Because he was always curious about what makes the digital world tick!

Jokeday Funday Part #3

Soumyadeep Dey — Sun, 23 Jul 2023 13:04:12 +0000

Jokeday Funday: Part 3 - Keep the Laughter Rolling with More Programming Jokes!

Joke 1: The Unending Loop

Why do programmers always carry an umbrella?

In case it starts raining while they're stuck in an infinite loop!

Joke 2: The Password Conundrum

Why did the programmer's password get rejected?

It didn't have enough characters to make a secure key to the heart of the system!

Joke 3: The Parallel Universe

Why do programmers always mix up Christmas and Halloween?

Because they believe that Oct 31 and Dec 25 are running in parallel universes!

Joke 4: The Memory Snatcher

Why did the memory module break up with the CPU?

It couldn't handle the CPU's commitment issues - always forgetting things!

Joke 5: The Language of Crowds

Why do programming languages get invited to parties?

Because they can always bring a large crowd, whether it's Java, Python, or C++!

Joke 6: The Time Traveling Coder

Why did the programmer start using a time machine while coding?

To debug issues from the past and prevent bugs in the future!

Joke 7: The Math Mystery

Why was the math book sad when it became a programmer's best friend?

Because it knew all the problems would be solved with code, not formulas!

Joke 8: The Job of a Compiler

Why did the compiler refuse to go on vacation?

It didn't want to leave its source code without proper supervision!

Joke 9: The Robotic Love

Why did the robot become a programmer?

Because it found its if statement was always true when it came to loving coding!

Joke 10: The Lost Developer

Why did the developer get lost on the way to the Git repository?

Because they didn't "commit" to the right path!

Bonus Joke: The Programming Prodigy

Why did Soumya become a computer programmer at such a young age?

Because he saw all the "byte-sized" snacks programmers could have while coding!

Enjoy the jokes, and may the laughter be with you! 😄

10 Tips For Writing Cleaner Code In Any Programming Language

Soumyadeep Dey — Tue, 18 Jul 2023 15:29:14 +0000

Introduction

Writing effective code is a skill that takes time and practice to develop. However, there are a few simple tips that can help you write code that is clear, concise, and easy to maintain. Clean code not only improves readability but also enhances collaboration and reduces the likelihood of introducing bugs.

Tip 1: Use Descriptive Variable Names

One of the most important things you can do to write effective code is to use descriptive variable names. Descriptive variable names make your code easier to read and understand, and they can help you avoid errors. Instead of using single-letter or abbreviated names, choose meaningful names that accurately convey the purpose of the variable.

Tip 2: Use Meaningful Comments

Comments can be a great way to explain what your code is doing. They can also be helpful for future developers who need to understand your code. Use comments to provide context, explain complex logic, or highlight important details. However, it's important to use comments sparingly and keep them up to date with the code.

Tip 3: Break Your Code into Functions

Functions are a great way to break your code into smaller, more manageable pieces. This makes your code easier to read, understand, and maintain. Each function should have a single responsibility and perform a specific task. Modularizing your code into functions promotes reusability and helps avoid repetition.

Tip 4: Use White Space Effectively

White space can be a great way to improve the readability of your code. Use blank lines to separate different sections of code, and use indentation to make your code easier to follow. Properly formatted code enhances visual clarity and makes it easier to identify logical blocks and hierarchy.

Tip 5: Use Consistent Coding Style

A consistent coding style makes your code easier to read and understand. This means using the same indentation style, variable naming conventions, and comment style throughout your code. Consistency creates a sense of familiarity, improves code comprehension, and helps maintain a cohesive codebase.

Tip 6: Use a Linter

A linter is a tool that can help you find errors in your code. Linters can also help you improve your coding style. Set up a linter in your development environment to automatically analyze your code for potential issues such as syntax errors, unused variables, or code smells. Regularly running a linter helps catch errors early and enforce coding standards.

Tip 7: Test Your Code

Testing your code is essential for ensuring that it works correctly. There are different types of tests you can perform, such as unit tests, integration tests, and end-to-end tests. Writing tests helps verify the behavior of your code, catch bugs, and facilitate refactoring. Adopting a test-driven development approach can lead to more reliable and maintainable code.

Tip 8: Document Your Code

Documenting your code can help future developers understand what your code does. Documentation can also be helpful for yourself, as it can remind you of what your code is doing. Include inline comments to explain complex logic, document function signatures, and provide high-level overviews of modules or classes. Additionally, consider generating external documentation using tools like JSDoc or Sphinx.

Tip 9: Use Version Control

Version control is a system that helps you track changes to your code. This can be helpful for debugging your code, collaborating with others, and it can also be helpful if you need to revert to a previous version of your code. Utilize version control systems such as Git to maintain a history of your code, create branches for experiments or new features, and collaborate seamlessly with other developers.

Tip 10: Read Other People's Code

One of the best ways to learn how to write effective code is to read other people's code. This can expose you to different coding styles, approaches to problem-solving, and coding best practices. Open-source projects, online code repositories, and community forums are great places to explore and analyze code written by experienced developers.

Conclusion

Writing clean and high-quality code is a continuous journey that requires attention to detail and deliberate practice. By following these ten essential tips, you can improve the readability, maintainability, and reliability of your code. Embrace the principles of clean coding, and strive to write code that is not only functional but also elegant and a pleasure to work with.