DEV Community: Mohit kadwe

🌟🎉 Interface Segregation Principle: Simplifying Interfaces for Better Code Design🚀🌈🖋️

Mohit kadwe — Mon, 04 Mar 2024 03:08:35 +0000

In the exciting world of software development, there are guiding principles that help us write better, more maintainable code. One such principle is the Interface Segregation Principle (ISP), which can be thought of as organizing your tools in a toolbox so that you only have what you need for each specific task. In this article, we'll explore ISP and how it can make our code cleaner and easier to work with, using examples even a school student can understand. 🚀📚

Introduction 🎉

Imagine you have a toolbox filled with various tools for different tasks. If you're fixing a bicycle, you only need a wrench and screwdriver, not a hammer and saw. Similarly, in programming, interfaces should contain only what each part of the code needs, not everything imaginable. 🧰🤓💻

Understanding the Interface Segregation 🧠

The Interface Segregation Principle (ISP) suggests that it's better to have several smaller, specialized interfaces rather than one large, generic interface. This way, each part of the code can use only what it needs, keeping things simple and organized. 🛠️

Key Concepts of ISP 🔑

Toolbox Analogy: Think of interfaces as toolboxes, and classes as workers who only need specific tools for their job. 🔧
Client-specific Interfaces: Just like different workers need different tools, different parts of our code need different interfaces. 📦
Keeping It Simple: By separating interfaces, we keep our code focused and easier to understand. 📏

Real-World Examples 🌍

Let's say we have a program for a school library. We might have two interfaces: Borrowable for books that can be borrowed and Readable for books that can be read online. Each book class can then implement the interface it needs, without unnecessary methods. 📚

interface Borrowable {
    void borrow(); 📚
    void returnBook(); 🔄
}

interface Readable {
    void open(); 🔓
    void close(); 🔒
}

class PrintBook implements Borrowable {
    // Methods for borrowing and returning
}

class eBook implements Readable {
    // Methods for opening and closing
}

Violation of ISP ❌

If we had a single LibraryItem interface with methods for both borrowing and reading, it would be like having a toolbox filled with tools for every job, making it confusing and inefficient. ❌

interface LibraryItem {
    void borrow(); 📚
    void returnBook(); 🔄
    void open(); 🔓
    void close(); 🔒
}

Adhering to ISP ✅

By using separate interfaces for borrowing and reading, we ensure that each part of our code only uses what it needs, making our program easier to manage and understand. ✅

interface Borrowable {
    void borrow(); 📚
    void returnBook(); 🔁
}

interface Readable {
    void open(); 🔓
    void close(); 🔒
}

Benefits of ISP 🌈

Less Confusion: Each part of our code only has what it needs, reducing complexity. 🧩
Easier Maintenance: With smaller, focused interfaces, it's easier to find and fix issues. 🔧
More Flexible: We can easily add new features without affecting unrelated parts of the code. 🌟

Best Practices 🚀

Think Like a Worker: Consider what each part of your code needs, just like a worker needing specific tools. 👩‍🔧
Keep It Small: Don't overload interfaces with unnecessary methods. Keep them focused on their specific task. 📏

Conclusion 🎉

The Interface Segregation Principle helps us keep our code organized and easy to work with, just like organizing a toolbox for different tasks. By separating interfaces and keeping them focused, we can create cleaner, more maintainable code that even a school student can understand. So, let's embrace ISP in our coding journey and build better software together! 💻🔧

Connect with me

Let's stay connected and keep the conversation going! Feel free to connect with me on my social media platforms for updates, interesting discussions, and more. I'm always eager to engage with like-minded individuals🌱, so don't hesitate to reach out and connect. Looking forward to connecting with you all! 🌟

Here's my link:

Mohit Kadwe | Instagram | Linktree

Full Stack Engineer

linktr.ee

🌟 Mastering Liskov Substitution Principle in Object-Oriented Programming 🚀

Mohit kadwe — Sat, 10 Feb 2024 16:14:30 +0000

Introduction 🚀

In the realm of coding, principles are like guiding stars, helping us navigate through the vast universe of software development. Among these guiding lights, the Liskov Substitution Principle (LSP) shines brightly, especially for those just stepping into the world of object-oriented programming (OOP). This blog is your map to understanding LSP, its importance, and how it shapes the way we write code in JavaScript. Let's embark on this journey together! 🤓💻

Understanding the Liskov Substitution Principle 🧠

Think of LSP as a rule that ensures subclasses can be used interchangeably with their base classes without causing any unexpected behavior. It's like making sure a toy car behaves like a real car when you play with it – no surprises! 🚗💨

Key Concepts of LSP 🔑

Behavioral Compatibility : Subclasses should act just like their parent classes, following the same rules and behaviors. It's like having different flavors of ice cream – they might look different, but they all taste like ice cream! 🍦
No Surprises : When you use a subclass, you shouldn't get any unexpected results. It's like ordering pizza and getting pizza, not tacos! 🍕❌🌮

Real-World Examples 🌍

Violation of LSP ❌

Imagine a shape class with a method to calculate area. Now, let's say we have a Square class that inherits from Shape. But if setting the width of a Square also changes its height, we're violating LSP because squares shouldn't behave like rectangles in this case. It's like trying to fit a square peg in a round hole – it just doesn't work! 🔲⚠️🔴

class Shape {
  getArea() {
    throw new Error("Not implemented");
  }
}

class Rectangle extends Shape {
  setWidth(width) {
    this.width = width;
  }

  setHeight(height) {
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

class Square extends Rectangle {
  setWidth(width) {
    this.width = width;
    this.height = width; // Oops! Changing height as well
  }

  setHeight(height) {
    this.height = height;
    this.width = height; // Oops! Changing width as well
  }
}

Adhering to LSP ✅

To stick to LSP, we need to rethink our design:

class Shape {
  getArea() {
    throw new Error("Not implemented");
  }
}

class Rectangle extends Shape {
  setWidth(width) {
    this.width = width;
  }

  setHeight(height) {
    this.height = height;
  }

  getArea() {
    return this.width * this.height;
  }
}

class Square extends Shape {
  setSideLength(sideLength) {
    this.sideLength = sideLength;
  }

  getArea() {
    return this.sideLength ** 2;
  }
}

Benefits of LSP 🌈

Code Flexibility : With LSP, you can swap subclasses in and out without breaking anything. It's like having Lego blocks that fit together perfectly, no matter which ones you choose! 🧱✨
Simpler Testing : When subclasses behave predictably, testing becomes easier. It's like solving a puzzle where all the pieces fit snugly into place! 🧩🔍

Best Practices

Know Your Classes : Understand what each class should do and make sure they stick to their jobs. It's like knowing who does what in your group project – each person has their role! 👩‍🏫📚
Test, Test, Test : Always test your code to make sure it behaves as expected. It's like double-checking your homework before turning it in – you want to get those A's! ✅📝

Conclusion 🎉

Liskov Substitution Principle might sound fancy, but it's all about making your code behave predictably and play nicely together. By following LSP, you're not just writing code; you're crafting a symphony where every part harmonizes perfectly. So, let's embrace LSP and write code that's not just functional but elegant too! 🌟

Happy coding, and remember, in the world of OOP, simplicity and focus are the keys to success! 👩‍💻🌟

Connect with me

Here's my link:

Mohit Kadwe | Instagram | Linktree

Full Stack Engineer

linktr.ee

🚀Navigating the GraphQL Galaxy🌌: A Comprehensive Roadmap for Developers 🚀

Mohit kadwe — Tue, 30 Jan 2024 01:44:14 +0000

Embarking on the journey of mastering GraphQL can be an exhilarating experience. This powerful query language has revolutionized the way developers interact with APIs, offering flexibility, efficiency, and a holistic approach to data fetching. Whether you're a seasoned developer or just starting, this comprehensive roadmap will guide you through the GraphQL galaxy, helping you explore its various facets.

🌐 GraphQL Basics: Laying the Foundation

Schema Definition 📄
Understand the fundamental building blocks of GraphQL by defining a schema that outlines your data types and their relationships.

Types 📊
Dive into scalar and custom types, exploring how they shape your data and define the core of your GraphQL schema.

Queries, Mutations, and Subscriptions 📝💥🔄
Master the art of querying data, executing mutations, and handling real-time updates through subscriptions.

Directives 🛠️
Learn to wield directives to control the execution of your GraphQL operations, providing a dynamic and customizable experience.

⚙️ GraphQL Operations: Behind the Scenes

Query Resolution, Mutation Execution, and Subscription Handling 📤⚡🎉
Delve into the inner workings of GraphQL operations, understanding how queries are resolved, mutations executed, and subscriptions handled.

🧑‍💻 GraphQL Schemas & Types: Crafting Your Data Model

Scalar Types and Enum Types 🌈🌐
Explore the diverse range of scalar types and delve into enumerations to enhance your data modeling capabilities.

Input Types 📥
Master the use of input types to facilitate cleaner and more maintainable mutations in your GraphQL schema.

🧰 GraphQL Resolvers: Bridging the Gap

Query and Mutation Resolvers, Resolver Arguments 📤💥🎯
Become proficient in writing resolvers, handling query and mutation resolution, and effectively managing resolver arguments.

🚀 Apollo Client: Conquering Client-Side GraphQL

Setup, Queries, Mutations, and Caching 🛠️📝💥🔄
Navigate the world of Apollo Client, from initial setup to performing queries, mutations, and efficient caching.

🔄 Relay Framework: Unleashing GraphQL’s Full Potential

Node Interface, Connections, and Pagination 🌐🔗📄
Unlock the advanced features of GraphQL with the Relay framework, handling connections, nodes, and paginating through large datasets.

🔒 Authentication & Authorization: Securing Your GraphQL API

JWT Authentication and Role-Based Access Control 🌐🔐🧑‍💼
Implement secure authentication using JSON Web Tokens and control access with role-based authorization.

🚨 Error Handling: Navigating the Troubles

*GraphQL Errors and Error Extensions ❌🚫🚀
*
Learn effective error handling strategies, understanding and extending GraphQL errors for a smoother development experience.

🌟 GraphQL Best Practices: Mastering Efficiency

Batched Resolvers, DataLoader, Debouncing & Throttling 🔄⚡⏲️
Discover best practices for optimizing GraphQL performance, including batching resolvers, using DataLoader, and managing data flow.

🌐 Federation: Embracing Microservices

Microservices Architecture, Service Definition, and Entity Resolution 🚀📄🎯
Dive into the world of GraphQL federation, architecting scalable systems using microservices and resolving entities seamlessly.

⚙️ Testing GraphQL: Ensuring Reliability

Unit Testing, Integration Testing, and Mocking 🧪🤝🃏
Learn the art of testing GraphQL applications, from unit tests to integration tests and effective mocking strategies.

🧰 GraphQL Tools & Libraries: Leveraging the Ecosystem

Apollo Server, Relay, Prisma, and GraphQL Yoga 🚀🔗🛠️🧘
Explore the rich GraphQL ecosystem, utilizing tools like Apollo Server, Relay, Prisma, and GraphQL Yoga to streamline development.

🌍 Real-world GraphQL: Applying Your Knowledge

Building APIs, Optimizing Queries, and Handling Large Datasets 🚀⚡📊
Apply your GraphQL expertise to real-world scenarios, building APIs, optimizing queries, and efficiently handling large datasets.

🔄🌐 GraphQL vs REST: Navigating the Paradigm Shift
Explore the fundamental differences between GraphQL and REST, understanding when and why GraphQL might be the preferred choice.

🚀🔮 Future of GraphQL: What Lies Ahead
Stay ahead of the curve by exploring the evolving landscape of GraphQL and anticipating future trends and advancements.

🤝📚 Community & Resources: Joining the GraphQL Movement

Conferences & Meetups 🌍🤝
Documentation 📚
Online Communities 🌐💬 Connect with the vibrant GraphQL community, attend conferences, explore documentation, and engage in online forums to enhance your learning experience.

🚀 GraphQL Knowledge Galaxy 🌌

|
|── GraphQL Basics 🚀
| ├── Schema Definition 📄
| ├── Types 📊
| | ├── Scalar Types 🌈
| | └── Custom Types 🧑‍💼
| ├── Queries 📝
| | ├── Basic Queries 🔍
| | ├── Query Variables 🧾
| | └── Fragments 🧩
| ├── Mutations 💥
| ├── Subscriptions 🔄
| └── Directives 🛠️
|
|── GraphQL Operations ⚙️
| ├── Query Resolution 📤
| ├── Mutation Execution ⚡
| └── Subscription Handling 🎉
|
|── GraphQL Schemas & Types 🧑‍💻
| ├── Scalar Types 🌈
| | ├── Int 🕵️‍♂️
| | ├── Float 🌊
| | ├── String 📝
| | ├── Boolean ✔️
| | └── ID 🆔
| ├── Enum Types 🌐
| └── Input Types 📥
|
|── GraphQL Resolvers 🧰
| ├── Query Resolvers 📤
| ├── Mutation Resolvers 💥
| └── Resolver Arguments 🎯
|
|── Apollo Client 🚀
| ├── Setup 🛠️
| ├── Queries 📝
| ├── Mutations 💥
| └── Caching 🔄
|
|── Relay Framework 🔄
| ├── Node Interface 🌐
| ├── Connections 🔗
| └── Pagination 📄
|
|── Authentication & Authorization 🔒
| ├── JWT Authentication 🌐🔐
| └── Role-Based Access Control 🧑‍💼🔐
|
|── Error Handling 🚨
| ├── GraphQL Errors ❌
| └── Error Extensions 🚫🚀
|
|── GraphQL Best Practices 🌟
| ├── Batched Resolvers 🔄⚡
| ├── DataLoader 📤📥
| ├── Debouncing & Throttling ⏲️
| └── Schema Stitching 🧵🌐
|
|── Federation 🌐
| ├── Microservices Architecture 🚀
| ├── Service Definition 📄
| └── Entity Resolution 🎯
|
|── Testing GraphQL ⚙️
| ├── Unit Testing 🧪
| ├── Integration Testing 🤝
| └── Mocking 🃏
|
|── GraphQL Tools & Libraries 🧰
| ├── Apollo Server 🚀
| ├── Relay 🔗
| ├── Prisma 🛠️
| └── GraphQL Yoga 🧘
|
|── Real-world GraphQL 🌍
| ├── Building APIs 🚀
| ├── Optimizing Queries ⚡
| └── Handling Large Datasets 📊
|
|── GraphQL vs REST 🔄🌐
|
|── Future of GraphQL 🚀🔮
|
|── Community & Resources 🤝📚
| ├── Conferences & Meetups 🌍🤝
| ├── Documentation 📚
| └── Online Communities 🌐💬
|
|____________ END __________________

🌈💻 Conclusion: Your GraphQL Odyssey Begins

As you navigate this comprehensive GraphQL roadmap, remember that learning is a journey, not a destination. Embrace the challenges, celebrate victories, and contribute to the ever-growing GraphQL community. Your GraphQL odyssey has just begun, and the possibilities are limitless! 🌈💻🚀

Let the GraphQL adventure commence! Share your experiences, insights, and newfound knowledge with the global developer community. Happy coding! 🚀🌐

If you have cool ideas or questions about making your code do awesome things, just drop a comment below! Let's chat and learn together! 👍💬

Connect with me

Here's my link:

Mohit Kadwe | Instagram | Linktree

Full Stack Engineer

linktr.ee

🌟 The Open-Closed Principle: Making Coding Fun & Flexible! 🎉

Mohit kadwe — Sat, 20 Jan 2024 06:50:01 +0000

Hey Young Coders! 🚀👦👧

Today, we're going on an exciting coding adventure to explore a super cool idea called the Open-Closed Principle (OCP)! 🌈 It's like a magic spell🎩 in the world of coding that helps us make our programs really awesome. Let's dive in and discover how it works, with fun examples and emojis! 🎮🐱‍👤

What's the Open-Closed Principle? 🤔

Imagine you have a box of LEGOs. You can build all sorts of things with it, right? 🏰🚗 The Open-Closed Principle in coding is kind of like that. It says that your code should be like a LEGO set:

Open for Extension : You can always add new LEGO pieces to build something new (like adding a rocket to your LEGO castle! 🚀🏰).
Closed for Modification : You don't need to break your existing LEGO model to add new pieces.

In simple words, OCP lets you add new features to your computer program without changing the old parts. Pretty neat, huh? 😎

Why Use OCP? 🌈🌟

No Breaking Old Toys : Just like you wouldn’t break your favorite toy to make a new one, OCP keeps the old code safe while adding new stuff. 🧸🔨
Be a Creative Coder : It lets you think of cool, new features without worrying about the old ones. 🎨👩‍💻
Less Oopsie-Daisies : Changing old code can sometimes cause errors, but with OCP, there's less chance of that. 🙅‍♂️💻

OCP in Action: A Fun Example 🎪 🏃‍♂️

*The Problem: A One-Trick Pony 🐴 *

Imagine we have a digital pet, a pony, that can only jump. But what if we want it to do more tricks like dancing or singing?

class Pony {
  jump() {
    console.log("The pony jumps! 🐴💨");
  }
}

The OCP Magic: A Multi-Talented Pony 🦄

Let's use OCP to teach our pony new tricks without changing its ability to jump.

class Pony {
  constructor(trick) {
    this.trick = trick;
  }

  perform() {
    this.trick.doTrick();
  }
}

class JumpTrick {
  doTrick() {
    console.log("The pony jumps! 🐴💨");
  }
}

class DanceTrick {
  doTrick() {
    console.log("The pony dances! 💃🐴");
  }
}

let jumpy = new Pony(new JumpTrick());
jumpy.perform(); // The pony jumps! 🐴💨

let dancy = new Pony(new DanceTrick());
dancy.perform(); // The pony dances! 💃🐴

See? We added dancing to our pony's skills without stopping it from jumping! 🎉

Best Practices 🎯

Anticipate Changes: Regular meetings and discussions about future requirements can help in designing more adaptable abstractions.
Prefer Composition: It offers more flexibility and adheres to OCP better than classical inheritance.
Embrace Extensions: Design your software entities to be easily extendable through additional classes or methods.

Conclusion: OCP is Super Cool! 🌠

So, friends, the Open-Closed Principle is like having a toy that never gets boring because you can always add new things to it! It makes coding more fun and lets your imagination run wild! 🌈👾

Remember, coding is like building with LEGOs – you can create anything you dream of! Keep building and keep smiling! 😄💻

If you have cool ideas or questions about making your code do awesome things, just drop a comment below! Let's chat and learn together! 👍💬

Connect with me

Here's my link:

Mohit Kadwe | Instagram | Linktree

Full Stack Engineer

linktr.ee

🌟 Embracing the Single Responsibility Principle for Better Code Quality in Object-Oriented Programming 🚀🌈🖋️

Mohit kadwe — Sun, 07 Jan 2024 09:28:30 +0000

Introduction 🚀

In the exciting world of object-oriented programming (OOP), the principles we adopt significantly influence the quality and sustainability of our code. Among these guiding principles, the Single Responsibility Principle (SRP) stands out as a cornerstone for creating maintainable and scalable software. This blog post delves into the depths of SRP, illustrating its importance and application in everyday coding practices, especially for those working with C#, web development, and beginners taking their first steps into OOP. 🤓💻

Understanding the Single Responsibility Principle🧠

The Single Responsibility Principle is more than just a rule; it's a mindset that shapes how we structure and think about our code. As the "S" in the famous SOLID acronym, SRP states that a class should have only one reason to change — meaning it should encapsulate just one responsibility.

Key Concepts of SRP 🔑

Focus on One Functionality: SRP posits that a class should handle one and only one task or concern. This approach reduces complexity and makes the code more intuitive.🎯
Separation of Concerns: This principle encourages developers to divide their systems into distinct segments, each responsible for a specific function. This separation fosters a modular structure, enhancing both readability and maintainability. 🧩

Real-World Examples 🌍

Violation of SRP❌

Consider an EmailService class that is responsible for both sending emails and logging them. This dual responsibility leads to a conflated design, where changes in the email sending logic might inadvertently affect the email logging process, thus complicating maintenance and updates.

public class EmailService 
{ 
    public void SendEmail(string to, string subject, string body) 
    { 
        // Code to send an email... 
    }

    public void SaveEmailLog(string to, string subject, string body)
    {
        // Code to save email log to a database...
    }
}

Adhering to SRP✅

By refactoring the above example, we can adhere to SRP:

public class EmailService 
{ 
    public void SendEmail(string to, string subject, string body) 
    { 
        // Code to send an email... 
    } 
}

public class EmailLogger 
{ 
    public void SaveEmailLog(string to, string subject, string body)
    { 
        // Code to save email log to a database... 
    } 
}

Benefits of SRP🌈

Improved Readability and Maintainability: With each class handling a single responsibility, the code becomes more intuitive and easier to navigate.📚
Easier Testing and Debugging: SRP allows for more straightforward unit tests since each class has a single focus.🧪
Minimized Ripple Effects: Changes in one part of the system are less likely to impact other parts, reducing the risk of bugs and regression.🌊

Best Practices

Design for a Single Task: Ensure that each class is focused on a single functionality.🎨
Regular Refactoring: Continuously review and refactor your code to align with SRP.🔍
Use Composition: Leverage composition over inheritance to combine functionalities from different classes.🤝
Design for Extensibility: Create classes that are open for extension but closed for modification.🚪
Clear Naming Conventions: Choose descriptive names for classes and methods that reflect their sole responsibility.🏷️

Conclusion 🎉

The Single Responsibility Principle is a powerful tool in the arsenal of any object-oriented programmer. By adhering to SRP, you lay the foundation for code that is not only easier to understand and maintain but also more robust and adaptable to changes. As we continue to evolve our coding practices, let's remember the immense value of keeping our classes focused and our responsibilities clear.

Happy coding, and remember, in the world of OOP, simplicity and focus are the keys to success! 👩‍💻🌟

Connect with me

Here's my link:

Mohit Kadwe | Twitter | Linktree

Linktree. Make your link do more.

linktr.ee

🔥🚀 Hacktoberfest 2023 : : The Beginner level Guidance ✨👩‍💻

Mohit kadwe — Sun, 01 Oct 2023 14:54:25 +0000

Table of content

Let's know something important first
what is Hactoberfest, hearing for the first time ?
What is a Pull Request?
Setting up Git and GitHub
Forking a Repository
Cloning the Forked Repository
Making Changes and Creating a New Branch
Committing Changes
Pushing Changes to GitHub
Creating a Pull Request
Conclusion: Hacktoberfest 2023

Let's know it something important first:

GitHub, the world's largest community of developers, provides a powerful platform for collaborative software development. One of the fundamental features that makes it so effective is the ability to use pull requests. This allows contributors to propose changes, discuss them, and eventually merge them into the main project. With Hacktoberfest 2023 around the corner, there's no better time to learn about this essential Git feature and start contributing to open-source projects.

what Hactoberfest, hearing for the first time ?

Hahaha! Don't worry, this article will help you to get the idea behind this annual coding fest running since last 10 years. Yes, you read it right! Every year, during the month of October techies celebrate a month long coding fest globally. This year, Hactoberfest is celebrating 10 years into the world of tech and open source 🚀. Join this celebration and contribute to the good code cause. Want to know my journey ? Read it here.

What is a Pull Request?

A pull request is a proposed change to a repository on GitHub. It allows contributors to submit their changes for review before merging them into the main branch. This process encourages collaboration and ensures that changes meet the project's standards.

Setting up Git and GitHub

Before you can start creating pull requests, you'll need to set up Git on your local machine and have a GitHub account. Follow these steps to get started:

Install Git: Download and install Git from the official website. This will provide you with the necessary tools to manage your code locally.
Create a GitHub Account: If you don't already have one, create an account on GitHub. This is where you'll host your repositories and contribute to others.
Configure Git: Set up your Git identity by running the following commands in your terminal:

git config --global user.name "Your Name"
git config --global user.email "youremail@example.com"

Forking a Repository

Before you can make changes to a project, you need to create a copy of it on your own GitHub account. This process is known as forking. Here's how you can do it:

Visit the Repository: Go to the GitHub page of the project you want to contribute to.
Fork the Repository: Click on the "Fork" button at the top-right corner of the repository's page. This will create a copy of the repository in your GitHub account.

Cloning the Forked Repository

Now that you have a copy of the repository in your account, you'll need to clone it to your local machine to start making changes. Follow these steps:

Get the Repository URL: Click on the "Code" button and copy the repository's URL
Open Your Terminal: Navigate to the directory where you want to store your local copy of the repository.
Clone the Repository: Use the following command, replacing <repository-url> with the URL you copied:

git clone <repository-url>

Making Changes and Creating a New Branch

With the repository cloned, you can now make your desired changes. However, it's best practice to create a new branch for your changes to keep the main branch clean. Here's how you can do it:

Create a New Branch: Use the following command to create a new branch, replacing <branch-name> with a descriptive name for your changes:

git checkout -b <branch-name>

Make Changes: Now you can make the necessary modifications to the code.

Committing Changes

Once you've made the desired changes, you'll need to commit **them to your local repository. This saves a **snapshot of your work. Use the following steps:

Add Changes: Add the files you want to commit using the following command:

git add .

Commit Changes: Commit your changes with a descriptive message:

git commit -m "Your descriptive message here"

Pushing Changes to GitHub

Now that you've committed your changes locally, it's time to push them to your GitHub fork. Use the following command:

git push origin <branch-name>

Creating a Pull Request

With the changes pushed to your fork, you can now create a pull request to propose the changes to the original repository. Follow these steps:

Visit Your Repository on GitHub: Go to your forked repository on GitHub.
Switch to Your New Branch: Select the branch you just created.
Create a Pull Request: Click on the "Pull Request" button.
Describe Your Changes: Write a clear and concise description of the changes you've made.
Submit the Pull Request: Click the "Create Pull Request" button.

Connect with me

Here's my link: https://linktr.ee/mohitkadwe

Conclusion: Hacktoberfest 2023

With the knowledge of pull requests, you're now ready to participate in Hacktoberfest 2023! This annual event celebrates open-source contributions and encourages developers to get involved in the open-source community. Find projects you're passionate about, make meaningful contributions, and help make the world of code a better place.

Remember, open-source thrives on collaboration, so don't hesitate to ask questions, seek feedback, and enjoy the experience of being part of a global community of developers.

I'm going to participate, see you on the other side. Happy coding!

Note: Check Hacktoberfest 2023 details and dates here