[EN] Project Development Guide with React — Emre MUTLU
Published: 2023-04-19 13:23:45


## [EN] Project Development Guide with React — Emre MUTLU

![](https://cdn-images-1.medium.com/max/2560/1*9135V_Ubzf6mTxaB-NGRrA.png)

**Hello,**
This guide contains rules that must be followed when developing applications with [React](https://reactjs.org/docs/getting-started.html#learn-react). This guide aims to ensure that the codes written by different people are compatible with each other and to produce higher quality codes with fewer errors. In other words, it is aimed that people working in a team coherently writing code.
**Note: *****Take everything here as an opinion**, not an absolute. There’s more than one way to build software.*

**About the Author**
For over two years, I’ve been developing projects with React. I learned the necessary information to enter this sector on the internet. That’s why I want to pay my debt to the community and contribute to the development of the community by sharing the knowledge I have gained on the internet.
>  “Knowledge grows as it is shared”



**CONTENTS:**

**WHAT TO KNOW BEFORE YOU START READING
**- Basic Javascript Information
- Why Did I Choose to Use VSCode?
- SOLID Principles

**WHAT TO DO
**- VSCode Settings
- Basic Principles
- Naming
- Formatting

**RECOMMENDED**
- Form Usage
- VSCode Snippets
- Leave it how you want to find it
- Asking for Help
- Starting with the Simple Things

**WHAT NOT TO DO
**- Avoid actions that will lead to loss of performance
- Avoid the Use of “Magic String”
- Avoid the Use of “Inline CSS”
- Avoid Writing Long Code
- Direct Object Intervention should be avoided
- Incorrect State Use Should Be Avoided
- Do You Need to Use Else?
- Do You Need to Use Array.push()?
- Avoid Props Drilling
- Bonus :)

**I WANT TO TAKE MY REACT KNOWLEDGE EVEN FURTHER
Last Word**

![Photo by [Ben White](https://unsplash.com/@benwhitephotography?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)](https://cdn-images-1.medium.com/max/12032/0*p6vcsO68afUzUChT)

### THINGS TO KNOW BEFORE YOU START READING

*There are too many technical terms in the text, so to explain them all, I added a link to the explanation for the subject mentioned in the technical terms. (Underlined phrases are clickable links.)*

### **Basic Javascript Information**

**Be sure to learn the basic Javascript information described in this article:** [https://www.freecodecamp.org/news/top-javascript-concepts-to-know-before-learning-react/](https://www.freecodecamp.org/news/top-javascript-concepts-to-know-before-learning-react/)
>  **Be sure to understand the following statement thoroughly.
“Everything is a component in React.”**
- Well, we use [HTML ](https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/HTML_basics)tags (eg: <div>…</div>).
+ Actually, it is a [React Component](https://reactjs.org/docs/react-component.html#gatsby-focus-wrapper); we are using [*JSX](https://reactjs.org/docs/introducing-jsx.html)*. We do not use [*HTML](https://www.freecodecamp.org/news/html-vs-jsx-whats-the-difference/)*.
For an introduction to JSX, read: [https://reactjs.org/docs/introducing-jsx.html](https://reactjs.org/docs/introducing-jsx.html)

**Note:** This guide assumes you are using the functional component. [Click](https://www.geeksforgeeks.org/differences-between-functional-components-and-class-components-in-react/#:~:text=Functional%20Components-,Class%20Components,which%20returns%20a%20React%20element.) to examine the differences between functional components and class components.

**Note:** This guide assumes you are using [VSCode](https://code.visualstudio.com/). If you use [Webstorm](https://www.jetbrains.com/webstorm/) or any other code editor, you can ignore the VSCode-related parts.

**Why did I choose to use VSCode?**
Because I love **VSCode’s** [code snippets system](https://code.visualstudio.com/docs/editor/userdefinedsnippets), shortcuts, the repository of add-ons, and customizability.
You can find detailed information about **VSCode **at this address: [https://code.visualstudio.com/docs/editor/whyvscode#:~:text=With%20support%20for%20hundreds%20of,navigate%20your%20code%20with%20ease](https://code.visualstudio.com/docs/editor/whyvscode#:~:text=With%20support%20for%20hundreds%20of,navigate%20your%20code%20with%20ease).

### SOLID Principles

If we apply the **SOLID** principles to REACT:
**S** = [Single responsibility principle (SRP)](https://betterprogramming.pub/how-to-apply-solid-principles-to-clean-your-code-in-react-cdfd5e0a9cea) => “Every function/module/component should do exactly one thing”

In the example below, user information and displaying the component are done in a component. This is a violation of the Single Responsibility Principle.

 

```
   const ActiveUsersList = () => {
      const [users, setUsers] = useState([])
      
      useEffect(() => {
        const loadUsers = async () => {  
          const response = await fetch('/some-api')
          const data = await response.json()
          setUsers(data)
        }
        loadUsers()
      }, [])
      
      const weekAgo = new Date();
      weekAgo.setDate(weekAgo.getDate() - 7);
      return (
        <ul>
          {users.filter(user => !user.isBanned && user.lastActivityAt >= weekAgo).map(user => 
            <li key={user.id}>
              <img src={user.avatarUrl} />
              <p>{user.fullName}</p>
              <small>{user.role}</small>
            </li>
          )}
        </ul>    
      )
    }
```
Instead of giving more than one responsibility to the component, we should split the duties into two different functions, as shown in the example below.

In the example below, user information access is assigned to the hook named useUser(). The responsibility of displaying the data (showing it in the interface) is given to the component called ActiveUsersList. This way, both functions have only one task.

  `  const useUsers = () => {
      const [users, setUsers] = useState([])
      
      useEffect(() => {
        const loadUsers = async () => {  
          const response = await fetch('/some-api')
          const data = await response.json()
          setUsers(data)
        }
        loadUsers()
      }, [])
      
      return { users }
    }
    const ActiveUsersList = () => {
      const { users } = useUsers()
      
      const weekAgo = new Date()
      weekAgo.setDate(weekAgo.getDate() - 7)
      return (
        <ul>
          {users.filter(user => !user.isBanned && user.lastActivityAt >= weekAgo).map(user => 
            <li key={user.id}>
              <img src={user.avatarUrl} />
              <p>{user.fullName}</p>
              <small>{user.role}</small>
            </li>
          )}
        </ul>    
      )
    }`



**O** = [Open-closed principle (OCP)](https://betterprogramming.pub/applying-the-open-closed-principle-to-write-clean-react-components-4e4514963e40) => “Software entities should be open for extension, but closed for modification”

In the example below, a Header component generates a new “Link” for each “pathname.” As the number of “paths” to be added to the application increases, the component will become quite complex. In other words, we must change the Header component for each new path we add.

```
const Header = () => {
      const { pathname } = useRouter()
      
      return (
        <header>
          <Logo />
          <Actions>
            {pathname === '/dashboard' && <Link to="/events/new">Create event</Link>}
            {pathname === '/' && <Link to="/dashboard">Go to dashboard</Link>}
          </Actions>
        </header>
      )
    }
    const HomePage = () => (
      <>
        <Header />
        <OtherHomeStuff />
      </>
    )
    const DashboardPage = () => (
      <>
        <Header />
        <OtherDashboardStuff />
      </>
    )

```
To prevent this situation, sending the links to the relevant page to the Header component within that page would be an excellent option.

   ` const Header = ({ children }) => (
      <header>
        <Logo />
        <Actions>
          {children}
        </Actions>
      </header>
    )
    const HomePage = () => (
      <>
        <Header>
          <Link to="/dashboard">Go to dashboard</Link>
        </Header>
        <OtherHomeStuff />
      </>
    )
    const DashboardPage = () => (
      <>
        <Header>
          <Link to="/events/new">Create event</Link>
        </Header>
        <OtherDashboardStuff />
      </>
    )
`
**L** = [Liskov substitution principle (LSP)](https://betterprogramming.pub/applying-the-liskov-substitution-principle-in-react-3a0614a42a08) => Objects in a program should be interchangeable with instances of their subtypes without changing the correctness of that program. This is a bit more related to classes. But if we try to adapt it to React, we can provide type control of the props passed to the component with PropTypes or TypeScript.

In the example below, both components are waiting for the same interface.

    `interface CatFact {
      facts: string[];
      color: string;
    }
    
    const CatFactA = ({ facts, color }: CatFact) => {
      return (
        <>
          {facts.map((fact, index) => (
            <p style={{ color }}>
              Fact {index}: {fact}
            </p>
          ))}
        </>
      );
    };
    
    const CatFactB = ({ facts, color }: CatFact) => {
      return (
        <ul style={{ color }}>
          {facts.map((fact) => (
            <li>{fact}</li>
          ))}
        </ul>
      );
    };
    
    export default () => {
      const catFactData: CatFact = {
        facts: [
          "Cats make about 100 different sounds. Dogs make only about 10.",
          "I don't know anything about cats.",
          "Domestic cats spend about 70 percent of the day sleeping and 15 percent of the day grooming."
        ],
        color: "red"
      };
      const abTest = Math.floor(Math.random() * 2) + 1;
      return (
        <div>
          {abTest === 1 ? (
            <CatFactA {...catFactData} />
          ) : (
            <CatFactB {...catFactData} />
          )}
        </div>
      );
    };`

**I **= [Interface segregation principle (ISP)](https://betterprogramming.pub/how-to-apply-interface-segregation-principle-in-reactjs-fadf77113c5d) => “Clients should not depend upon interfaces that they don’t use.”

In the example below, the component named DisplayUser has retrieved the entire user object via props to access the user’s name. In other words, there may be many expressions in the user object that the component named DisplayUser is not interested in — for example, the user’s hair color, age, etc.

    `const DisplayUser = (props) => {
      return (
        <div>
          <h1>Hello, {props.user.personalInfo.name}! </h1>
        </div>
      )
    };
    
    const App = () => {
      const user = {
        personalInfo: {
          name: "josh",
          age: 23
        },
        physicalFeatures: {
          hairColor: "blone",
          heightInC,: 175
        }
      }
      return (
        <div>
          <DisplayUser user={user} />
        </div>
      )
    };`

Instead of passing the whole user object from the parent component to the child component named DisplayUser, we should pass only the object that concerns that component.

In the example below, since DisplayUser is only interested in the user’s name, it will be enough to pass it through the props.

    `const DisplayUser = ({name}) => {
      return (
        <div>
          <h1>Hello, {name}! </h1>
        </div>
      )
    };
    
    const App = () => {
      const user = {
        personalInfo: {
          name: "josh",
          age: 23
        },
        physicalFeatures: {
          hairColor: "blone",
          heightInC,: 175
        }
      }
      return (
        <div>
          <DisplayUser name={user.personalInfo.name} />
        </div>
      )
    };`

**D** = [Dependency inversion principle (DIP)](https://betterprogramming.pub/apply-the-dependency-inversion-principle-in-react-c20a0afc3d64) => “One should depend upon abstractions, not concretions”

In the example below, API is called directly inside the LoginForm component. However, this makes the LoginForm component directly dependent on API.

   ` import api from '~/common/api';
    
    const LoginForm = () => {
      const [email, setEmail] = useState('');
      const [password, setPassword] = useState('');
    
      const handleSubmit = async (evt) => {
        evt.preventDefault()
        await api.login(email, password)
      }
    
      return (
        <form onSubmit={handleSubmit}>
          <input type="email" value={email} onChange={e => setEmail(e.target.value)} />
          <input type="password" value={password} onChange={e => setPassword(e.target.value)} />
          <button type="submit">Log in</button>
        </form>
      )
    }`

To prevent this situation, we need to create a parent component that can connect the LoginForm component and the API object like glue and enable them to communicate.

    

```
type Props = {
      onSubmit: (email: string, password: string) => Promise<void>
    }
    const LoginForm = ({ onSubmit }: Props) => {
      const [email, setEmail] = useState('')
      const [password, setPassword] = useState('')
      const handleSubmit = async (evt) => {
        evt.preventDefault()
        await onSubmit(email, password)
      }
      return (
        <form onSubmit={handleSubmit}>
          <input type="email" value={email} onChange={e => setEmail(e.target.value)} />
          <input type="password" value={password} onChange={e => setPassword(e.target.value)} />
          <button type="submit">Log in</button>
        </form>
      )
    }

    import api from '~/common/api'
    const ConnectedLoginForm = () => {
      const handleSubmit = async (email, password) => {
        await api.login(email, password)
      }
      return (
        <LoginForm onSubmit={handleSubmit} />
      )
    }
```

** For example, you should not do data fetching in a component. The Component’s job is to render. It doesn’t need to know anything else. For this reason, we should do the data extraction in a different method and only pass the result of this data extraction to the Component.*

(Code examples above:
- [https://konstantinlebedev.com/solid-in-react/](https://konstantinlebedev.com/solid-in-react/)
- [https://medium.com/docler-engineering/applying-solid-to-react-ca6d1ff926a4](https://medium.com/docler-engineering/applying-solid-to-react-ca6d1ff926a4)
taken from their addresses).

![Photo by [Alvan Nee](https://unsplash.com/@alvannee?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)](https://cdn-images-1.medium.com/max/10608/0*ubpmjv3etuCVJ_id)

### **WHAT TO DO**

**1. VSCode Settings**
First of all, it is mandatory to use the “[ESLint](https://eslint.org/docs/latest/user-guide/getting-started#:~:text=ESLint%20is%20a%20tool%20for,uses%20Espree%20for%20JavaScript%20parsing.),” “[Prettier](https://prettier.io/docs/en/#:~:text=Prettier%20enforces%20a%20consistent%20code,account%2C%20wrapping%20code%20when%20necessary.),” and “[GitLens](https://marketplace.visualstudio.com/items?itemName=eamodio.gitlens#:~:text=GitLens%20is%20an%20open%2Dsource,and%20why%20the%20code%20evolved.)” plugins for the VSCode application.
**Why is it mandatory?**
- **ESLint **instantly warns you about your mistakes and prevents you from building incorrectly.
- **Prettier **allows your** **codes to be formatted within the framework of your specific settings. (For example: Let a maximum of 120 characters be displayed on a line, more on the bottom line. Or end each variable with a semicolon after it is defined.) ([We usually use Prettier at the time of saving.](https://www.robinwieruch.de/how-to-use-prettier-vscode/))
- **GitLens** is a tool that allows you to do your Git operations from the VSCode interface. (You can see which line was added by who and with which commit message. In this way, you can better analyze the purpose of the written code.).
* Install the “[Emre MUTLU — Javascript — Extension Pack](https://marketplace.visualstudio.com/items?itemName=EmreMUTLU.emre-mutlu---javascript---extension-pack)” add-on package if you wish.

![Emre MUTLU — Javascript — Extension Pack](https://cdn-images-1.medium.com/max/2800/1*OQCZ-wteEgCzU7GwswLyFw.png)

The standard “[Commit](https://git-scm.com/docs/git-commit)” format must be implemented on git. (For example, you can consider the commit messages system here and expand it by adding new rules for your projects. (Example: [https://github.com/emremutlu08/react-best-practices/blob/main/common-commit-format/common-commit-format.md](https://github.com/emremutlu08/react-best-practices/blob/main/common-commit-format/common-commit-format.md))

**2. Basic Principles
**- ****The principles of “[DRY, KISS, and YAGNI](https://henriquesd.medium.com/dry-kiss-yagni-principles-1ce09d9c601f)” must be followed.
 — DRY = Don’t Repeat Yourself: You should not have duplicated code.
 — KISS = Keep It Super Simple (Orj: Keep It Simple, Stupid): Make your code simple
 — YAGNI = You Ain’t Gonna Need It: You should not create features that it’s not really necessary.

- It would be best if you put the “[Single Responsibility](https://blog.devgenius.io/single-responsibility-principle-within-the-react-ecosystem-155650ab7a00)” principle into practice.
- All components must have an id. (This way, it will be easier for us to [debug](https://raygun.com/blog/react-debugging-guide/).) These IDs should not conflict with each other.
Therefore, if the React version used in the project is less than 18, use the expression => **id = Math.floor(Math.random() * 100 + 1) + ‘-’ + FILE_NAME**,
If it’s large, you can use the expression **id = useId() + ‘-’ + FILE_NAME**.
- **Everything has to be a component** if it will use more than once.
- All props used in the Component **FILE_NAME.propTypes = { … props should be added here }
**- If mapping on a component array, adding a unique key value to the component in the most inclusive position is mandatory.
- Limit nested folders to 3–4 levels to avoid complexity.

**3. Naming**

![Pay attention to naming conventions.](https://cdn-images-1.medium.com/max/2000/1*f0Tz3DbeyTLRPfKlQI9CFw.jpeg)

* Proper and descriptive nomenclature is mandatory. (For example, instead of typing isModelOneOpen or shortening it to isModOnOp, you should name it isCreateModelOpen long and descriptively.) This way, you don’t have to add comments to explain it.

* Constant names should be [Snake Case (All Caps)](https://betterprogramming.pub/string-case-styles-camel-pascal-snake-and-kebab-case-981407998841). (THANKS_FOR_READING)

* File and folder names should be [kebab-case](https://betterprogramming.pub/string-case-styles-camel-pascal-snake-and-kebab-case-981407998841). (thanks-for-reading)

* Function names should be [camelCase](https://betterprogramming.pub/string-case-styles-camel-pascal-snake-and-kebab-case-981407998841). (thanksForReading)

* Component names should be PascalCase. (ThanksForReading)

* Custom hook names must start with useSmt (Ex: useWindowSize)

**4. Formatting**

* Write third-party (e.g., [npm packages](https://www.npmjs.com/)) imports at the top (in alphabetical order if possible). Write the in-app imports at the bottom.

* Common “ESLint” and “Prettier” settings are mandatory for all new projects. (For example, you can use the settings available here: [https://github.com/emremutlu08/emre-mutlu---javascript---extension-pack/tree/main/prettier-and-eslint-files](https://github.com/emremutlu08/emre-mutlu---javascript---extension-pack/tree/main/prettier-and-eslint-files))

* Before committing your code, make sure that the formatting is correct.

![Photo by [Erda Estremera](https://unsplash.com/@erdaest?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)](https://cdn-images-1.medium.com/max/8576/0*GMvsInShT1zKRR1n)

### RECOMMENDED

### Form Usage

* **To prevent frequent state changes**, it will be helpful to use input fields within the <form></form> tag and to get the information in case of onSubmit. (React applications “[render](https://reactjs.org/docs/rendering-elements.html)” happens “on every [state](https://reactjs.org/docs/state-and-lifecycle.html) change”. If this happens too often, it negatively affects application performance.)
**Note: ***You can also use the [useMemo](https://reactjs.org/docs/hooks-reference.html#usememo) hook to avoid unnecessary rendering in different situations.*
{% gist https://gist.github.com/emremutlu08/e2d051f0db8740399d6b8c023663f077.js %}{% gist https://gist.github.com/emremutlu08/baf74732f23eb2720feeae5181c237bb.js %}
Note: If you have more than one button in a <form>…</form>, you must provide a type for every button element.

    <form className="flex justify-content-between" onSubmit={() => {}}>
      <InputElement id="Name" name="Name" label={NAME_INPUT_TEXT} required />
      <BackButton type="button" onClick={onBack} /> // This is not invokes onSubmit
      <SendButton type="submit" /> // This invokes onSubmit
    </form>

### VSCode Snippets

* Create “[VSCode snippets](https://code.visualstudio.com/docs/editor/userdefinedsnippets)” (code snippets) for frequently used expressions. (This way, you avoid spending too much time on things that must be written repeatedly.)
*(You can use this tool to quickly generate snippets: [https://snippet-generator.app/](https://snippet-generator.app/))*

![We type ‘fa’, and the snipped appears.](https://cdn-images-1.medium.com/max/2528/1*-DQ7rSG-jE9pVFTaDm_-JA.gif)

### Leave it how you want to find it

* **Leave it the way you want to find it:** Someone who came before you may have left the code messy, did copy-paste work, in short, left a poor quality code. You should fix the code whenever you find the opportunity so that you and the people who come after you will encounter more understandable codes.
{% gist https://gist.github.com/emremutlu08/a277e05c0c5c3ae54cbe9c973ff4430a.js %}{% gist https://gist.github.com/emremutlu08/82ed8144afd7fcf8d187bc0d99c02e33.js %}
### Asking for Help

**It is recommended to ask for help: **After you have done enough research and are sure that you cannot reach the result on your own, you should ask a teammate for help. Because you can get the answer quickly thanks to them saying a keyword you did not think of at that moment.

### Starting with the Simple Things

**It is recommended to start with simple tasks:** Divide the task into small parts and always make simple tasks your priority. In this way, both “I could not progress in this process!” You get rid of the feeling, and you can tell your manager, “I have completed parts a, b, and c of this process, and only part X remains.”
If you start working from “X” to solve the difficult one, and your manager asks you, “what did you do” three days later, it wouldn’t be nice to say I’m still on “X,” right? :)

![Photo by [Nik](https://unsplash.com/@helloimnik?utm_source=medium&utm_medium=referral) on [Unsplash](https://unsplash.com?utm_source=medium&utm_medium=referral)](https://cdn-images-1.medium.com/max/7350/0*BmT3JJv5er9jKQwV)

### WHAT NOT TO DO

### Avoid actions that will lead to loss of performance

* Anything that will not be used on the current screen should not be called beforehand. (Especially at the beginning, it is necessary not to call everything and reduce the application’s performance.)

### Avoid the Use of “Magic String”

* It is necessary to avoid using strings that appear suddenly in the file called “[Magic String](https://deviq.com/antipatterns/magic-strings/)”.
* For example: (Type **item.userTypeId === userTypeEnum.Admin **instead of **item.userTypeId === 2**) should be written so that it is easy to read, and you don’t repeatedly look to see what Admin’s code was. (At the same time, if the Admin’s code changes, you will save yourself the hassle by changing it in one place.)
* Example-2: (Use **<button>{EDIT_BUTTON_TEXT}</button> **instead of **<button>EDIT</button>**). (You can also use [i18next](https://react.i18next.com/), which provides convenient localization operations.)

### Avoid the Use of “Inline CSS”

* It is necessary to avoid using “[Inline CSS](https://www.pluralsight.com/guides/inline-styling-with-react)” and proceed based on “Component” as much as possible. Because when there is a CSS change, changing it one by one from everywhere causes big problems.

### Avoid Writing Long Code

* Line length in a file should never exceed 500 lines. If you have written more than 300 lines of code, you should check what you wrote, divide it into meaningful parts / use it by separating it into methods. You have to import from different files.

### Direct Object Intervention should be avoided

* Do not interfere with an object as directly as possible. You must create a new copy of the object and modify it.

### Incorrect State Use Should Be Avoided

* Do not try to change the state information without using setState.

### Do You Need to Use Else?

* Avoid unnecessary if-else statements when you add the return statement in the if; the following statements do not work. So you don’t need to use else.

### Do You Need to Use Array.push()?

* Instead of array.push(), [array restructuring](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment), and appending should be done.
* […previousArray, { newObjectElement1: newObjectElementValue1 }]

### Avoid Props Drilling

* Avoid [Props Drilling](https://www.geeksforgeeks.org/what-is-prop-drilling-and-how-to-avoid-it/). (If your props reach more than two component levels, you are doing “Props Drilling”.)

### Bonus :)

* Please do not send requests in a for loop. :)

### I WANT TO CARRY MY REACT KNOWLEDGE FURTHER

MUST READ:
**- [**https://reactjs.org/docs/thinking-in-react.html](https://reactjs.org/docs/thinking-in-react.html)
- [https://alexkondov.com/tao-of-react/](https://alexkondov.com/tao-of-react/)
- [https://www.patterns.dev/](https://www.patterns.dev/)
- Learn the basics of Javascript very well.
- [https://reactpatterns.com/](https://reactpatterns.com/)

**Last Words:**

We have come to the end of the guide, where I try to convey my experiences with React. I hope you have gained helpful information for yourself and your team in this article.
If you want to give **helpful **feedback on this guide, you can reach me on [LinkedIn](https://www.linkedin.com/in/emremutlujs/).

— 
I want to thank all my friends who helped me develop this guide with their feedback. :)
 —

I’m thinking of collecting the guide you read in a git repo under “React Best Practices” and sharing it on Github.
If you want to support me in this work and contribute to the development of the React ecosystem, you can give a star to the Github repo.

**GitHub Repo:** [https://github.com/emremutlu08/react-best-practices](https://github.com/emremutlu08/react-best-practices)

**You can join my LinkedIn network with +26,000 followers to follow my daily posts about React and JavaScript:** [https://www.linkedin.com/in/emremutlujs/](https://www.linkedin.com/in/emremutlujs/)

**Resources and Examples:**

* [https://code.visualstudio.com/docs/editor/whyvscode#:~:text=With%20support%20for%20hundreds%20of,navigate%20your%20code%20with%20ease.](https://code.visualstudio.com/docs/editor/whyvscode#:~:text=With%20support%20for%20hundreds%20of,navigate%20your%20code%20with%20ease.)

* [https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/HTML_basics](https://developer.mozilla.org/en-US/docs/Learn/Getting_started_with_the_web/HTML_basics)

* [https://deviq.com/principles/dont-repeat-yourself](https://deviq.com/principles/dont-repeat-yourself)

* [https://www.freecodecamp.org/news/best-practices-for-react/amp/](https://www.freecodecamp.org/news/best-practices-for-react/amp/)

* [https://www.freecodecamp.org/news/html-vs-jsx-whats-the-difference/](https://www.freecodecamp.org/news/html-vs-jsx-whats-the-difference/)

* [https://www.freecodecamp.org/news/top-javascript-concepts-to-know-before-learning-react/](https://www.freecodecamp.org/news/top-javascript-concepts-to-know-before-learning-react/)

* [https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716](https://gist.github.com/joshbuchea/6f47e86d2510bce28f8e7f42ae84c716)

* [https://gokhana.medium.com/single-responsibility-prensibi-nedir-kod-%C3%B6rne%C4%9Fiyle-soli%CC%87d-c8b1602be602](https://gokhana.medium.com/single-responsibility-prensibi-nedir-kod-%C3%B6rne%C4%9Fiyle-soli%CC%87d-c8b1602be602)

* [https://medium.com/dailyjs/applying-solid-principles-in-react-14905d9c5377](https://medium.com/dailyjs/applying-solid-principles-in-react-14905d9c5377)

* [https://reactjs.org/docs/getting-started.html#learn-react](https://reactjs.org/docs/getting-started.html#learn-react)

* [https://reactjs.org/docs/introducing-jsx.html](https://reactjs.org/docs/introducing-jsx.html)

* [https://reactjs.org/docs/react-component.html#gatsby-focus-wrapper](https://reactjs.org/docs/react-component.html#gatsby-focus-wrapper)

* [https://reactjs.org/docs/rendering-elements.html](https://reactjs.org/docs/rendering-elements.html)

* [https://reactjs.org/docs/state-and-lifecycle.html](https://reactjs.org/docs/state-and-lifecycle.html)

* [https://reactjs.org/docs/thinking-in-react.html](https://reactjs.org/docs/thinking-in-react.html)

**Writer:**
* Emre MUTLU — [Linkedin](https://www.linkedin.com/in/emremutlujs/)

**Supporters with their Feedback:**
* Ahmet Emre BAŞAKÇIOĞLU — [Linkedin](https://www.linkedin.com/in/ahmet-emre-basak%C3%A7%C4%B1o%C4%9Flu-78751329/)
* Melike ŞANLI ARSLAN — [Linkedin](https://www.linkedin.com/in/melike-%C5%9Fanl%C4%B1-arslan-a4807099/) — [Medium](https://medium.com/@melikesanli12)
* Ezgi BIÇAK — [Linkedin](https://www.linkedin.com/in/ezgi-b%C4%B1%C3%A7ak-29b304142/) — [Medium](https://medium.com/@ezgibicak)
* Ercan AKALAR — [Linkedin](https://www.linkedin.com/in/ercanakalar/)

**Translators: **
* Emre MUTLU — [Linkedin](https://www.linkedin.com/in/emremutlujs/)
* Seha ÖZBEK — [Linkedin](https://www.linkedin.com/in/seha-ozbek/)