강의

멘토링

커뮤니티

NEW
Programming

/

Web Development

Properly Learning React: Mastering the Essence of Rendering and Declarative UI through Missions [Part 1 – Fundamentals]

This is not just a lecture you listen to and forget. This course aims not for "the moment you understand React" but for "the moment you can actually handle React." In every section, you'll complete missions alongside the lectures, solve practice problems directly, and learn by implementing core concepts like JSX, Virtual DOM, State, and useEffect with your own hands. When you complete the course, you won't just be a beginner who knows React syntax, but a developer who can explain and utilize everything from component design to rendering flow on your own. "Not just a class you listen to, but learning you build to completion." Understand the essence of React and experience the world of declarative UI firsthand.

(5.0) 2 reviews

54 learners

  • nhcodingstudio
실습 중심
미션기반
프론트엔드기초
HTML/CSS
JavaScript
React
Web Application
frontend

What you will gain after the course

  • Structurally understand the role React performs on top of the browser's rendering engine.

  • It shifts from the mindset of "directly manipulating the DOM" to "declaring the UI."

  • You can clearly explain the flow of "Rendering = Data(State) → Screen(UI)" through both code and concepts.

  • Learn the process of how JSX is transformed into React.createElement() through Babel with visual examples.

  • You can break down the UI into small units, pass data through props, and design a modular structure.

  • You can explain the principles of why, when, and how the screen is redrawn when state changes.

  • Ensures predictable rendering through patterns of copying and updating objects or arrays.

  • Understand the reasons why multiple state changes are batched together and React's rendering scheduling approach.

  • Practice the pattern of safely retrieving the previous state (prev) to calculate a new state.

  • Clearly recognize the boundary between data given by parents (props) and data that changes internally (state).

  • Learn React's principle of "data flows from top to bottom" in a structured way.

  • Understand the specific diffing rules of Virtual DOM and component reuse conditions.

  • Analyzes the rendering process that occurs when changing state within event handlers, with examples.

  • React's Core Philosophy: Mastering Unidirectional, Declarative, Component-Based Approach

  • You can create reusable components through children, props drilling, and destructuring.

  • Implement interactive UI that responds to user input or button clicks.

  • Visualizes the step-by-step process of how React calculates the Virtual DOM and reflects it to the actual DOM.

  • You naturally acquire the mindset of connecting data and UI instead of using DOM commands.

  • You can track and explain why this part was re-rendered again by yourself.

  • Through hands-on practice and missions in each section, you'll experience the "essence of rendering" firsthand and develop genuine React thinking.

🎓Learn React Properly: Completing Declarative UI with Missions [Basics]

React is a rendering engine that completely redefined "how data changes translate to the screen."

This course is not about React's surface appearance but its essence,
that is, the principles of rendering and the mindset of declarative UI, a complete beginner's guide that teaches you step by step from the beginning.

Many beginners start with React by learning JSX or useState syntax first,
but this course starts from "why did these syntaxes come to exist?"
HTMLDOMVirtual DOMReact rendering structure, perfectly connecting the big flow,
and you'll master how React draws the screen, why it re-renders when state changes,
by seeing and practicing all these processes with your own eyes.

🧱 Core Philosophy of Course Structure

📌 "Understand the structure rather than memorizing code."
→ Learn how JSX, props, and state work through principles, not just syntax.
📌 "Rendering is not magic, but a flow."
→ The process of state change → Virtual DOM → actual screen update can be felt at your fingertips.
📌 "Train declarative thinking."
→ Move away from imperative patterns centered on DOM manipulation and learn React's declarative mindset through hands-on practice.
📌 "Hands-on Mission-Based Learning"
→ Each section includes missions where you write code directly and verify the results visually.

✨ Features of This Course

  1. The only introductory course to visually understand the 'essence of rendering'
    → Directly visualizes the process of React comparing the Virtual DOM and reflecting it to the actual DOM.

  2. Step-by-step connection from JSX, createElement, to Virtual DOM
    → Rather than simply using JSX syntax, you'll understand at the code level what function calls happen internally.

  3. The complete connection between state, props, events, and rendering
    → You'll be able to accurately explain "why the screen changes when you click a button."

  4. Training to shift thinking from imperative to declarative
    → Practice React-style thinking centered on "what to display."

  5. Hands-on learning from immutability to batch updates
    → Directly observe how rendering optimization works during state changes through DevTools.

  6. Structural thinking training, not just simple coding practice
    → Designed to help you understand "React's entire rendering flow" beyond just a single line of code.

  7. All lectures are linked with practical missions
    → Through section-based missions, you will "directly verify understood concepts with code."

  8. 'Principle-based' foundational design that lasts once learned
    → Rather than simple copying, you'll develop the ability to apply React in any situation based on understanding React's operating principles.This becomes the foundation for CRP optimization).


1️⃣ Why React emerged:Understand the necessity of declarative UI by examining the limitations of existing approaches.

2️⃣ Visualizing DOM and Rendering Structure: Learn the principles of how screens are created and updated.

3️⃣ Establishing Component-Based Thinking: Learn structural thinking that divides screens into smaller parts and reuses them.

5️⃣ Complete Mastery of the Essence of Rendering: Master the process of how React redraws the screen by tracking it with DevTools.

4️⃣ Understanding the Connection Between Events and State: Directly experiment with how clicks cause screen changes.

6️⃣ Imperative → Declarative Mindset Shift: Training in React-style thinking that declares 'what' to render.

7️⃣ Principles of Immutability and Data Flow: Design the structure so that screen updates are predictable when state changes occur.

8️⃣ Complete Styling Process Learning: Learn strategic approaches by comparing Vanilla CSS, Modules, and CSS-in-JS for the right situations.

9️⃣ Separation of Design Tokens, Logic, and Views (SoC): Learn the sense of scaling to a structured project architecture

🔟Complete mastery through practical missions: Experience React's flow at your fingertips by directly implementing UI elements like buttons, themes, and icons.

For those who know HTML·CSS but are curious about "why" the screen changes

React users who have heard of it but don't know how to get started


React users who want to visually confirm the real principles behind how React re-renders the screen

Those who want to know what DOM is and how JavaScript moves the screen

I understand the concept, but when I try to implement it directly in code, I get stuck


React beginners who want to logically organize the fundamentals

Those who are hearing terms like rendering and state for the first time or are still confused about them


Those who want to break away from imperative coding methods and shift to more efficient thinking


"I want to properly learn React all the way through at least once" - for those who have this feeling

After taking the course

  • You can directly explain "why the screen changes like this."

  • You will understand how HTML, CSS, and JS work together to create UI.

  • You will completely master the rendering principles that update the screen with a single button click.

  • We implement the state concept directly in code and visually confirm the flow of changes.

  • The immutability mindset of "copying and replacing data instead of directly modifying it" naturally becomes ingrained in your thinking.

  • You will come to understand for yourself why event handling and flow control (onClick, onChange, etc.) are important.

  • I accurately understand the reason for Strict Mode where React renders twice to check for purity.

  • Learn to safely handle object and array states while developing predictable code writing habits.

  • Learn modern styling strategies by comparing Vanilla CSS, Modules, and styled-components.

  • You will develop the ability to logically trace "why the screen changes this way" for every line of code.

🎯 React Part 1 – Mission Summary Table


🟩 React Event Handling Practice — Outputting the Name and Index of Clicked List Items
This is the first step in experiencing React's event system.
When each item is clicked, it outputs the name and index of which item was selected,
helping you understand how the onClick event handler works.
You'll directly experience the principle of how JS function calls connect with React's event objects.


🟥 Experience the Power of State in React — Update Screen Numbers with Button Clicks
You'll realize that React is not just a simple screen library, but a "state-based rendering engine."
When you click a button, numbers automatically update, and you'll learn how useState connects to rendering.
You'll understand React's core philosophy that UI is "the result of data."

🟧 Event and State Integration Practice — Changing Toggle State with Clicks
Combine events and state to create an interactive UI that switches ON/OFF with each click.
Learn the structure where a single state variable changes the entire UI,
and get hands-on experience with the flow where rendering occurs again when setState is called.

🟪 Pure Component Practice — Maintaining Same Input → Same Output Without External Variables
We'll confirm through practice that the essence of React components is being "pure functions."
We'll improve code to ensure that the same screen is always output when the same props come in, without depending on external variables.
We emphasize the importance of predictable component structure.

🟦 Just changed the city but the screen doesn't update? — Safely updating nested object state with 'copying'
Learn through practical examples that React's state uses shallow comparison (reference value comparison).
Experience through code that to modify only part of an object's interior, you must create a new object through copying.
This is a core practice session that builds the fundamentals of immutability.

🟩 I added a to-do but the screen doesn't change! — Three techniques for maintaining immutability in array updates
When updating array state, use functions that return new arrays like concat, filter, map instead of push.
Learn clearly why React fails to detect changes
and why maintaining immutability causes the screen to update immediately.

🟪 Why didn't the screen change when the name was updated? — Safely updating nested objects in arrays
This covers advanced state updates when objects are nested inside arrays.
Learn the pattern of using map to find specific objects, copy them, and then modify them,
and gain a deep understanding of how React re-renders only when references change.

🟧 Apply Coupons All at Once! — Batch Update Multiple Items That Meet Conditions with Immutability
We'll cover the "update multiple items simultaneously" pattern that frequently appears in real-world development.
By combining map with conditional statements, we'll modify only items that meet specific conditions,
and visually confirm how React rendering is reflected across the entire array.

🟫 The Secret to Sibling Components Communicating — Lifting State Up to Parent for Synchronization
Implement a structure where two sibling components share the same state.
Learn the concept of "Lifting State Up" and
understand that data flow is unidirectional while experiencing the importance of props passing.

🟥 React directly manages values! — Controlling single inputs with controlled components
Practice the principle where values in input forms are not stored directly in the DOM, but React state "manages them instead."
Understand the connection structure between value and onChange,
and confirm that form inputs become completely predictable through controlled components.

🟧 Creating a Sign-up Form — Managing Multiple Inputs with Object State
As forms grow larger, managing each input value individually becomes difficult.
{ name, email, password } Learn the pattern of bundling them into an object state
and updating with setState({ ...prev, [key]: value }) for each input change.

🟪 My Preference Settings Form — Making Select·Checkbox·Radio All Controlled Components
Connect all various input types in forms to React state and manage them as a "single source of truth."
Clearly master the concept that React directly controls values instead of browser default behavior.

🟦 Completing the Registration Form — Implementing Submission Flow and Validation
We'll complete the flow that validates form input values and shows error messages when conditions aren't met during submission.
We'll comprehensively cover onSubmit events, preventDefault(), and simple validation logic.
This is a practical assignment where you'll directly design "state-based form logic" with React.

🟩 Dark Mode Toggle — Synchronizing body class with useEffect(…, [dark])
Use useEffect's dependency array to synchronize external environment (DOM) with React state.
Automatically update body.classList whenever the state value changes
to learn a structure where React controls even the actual HTML state.

🟦 Sending HTTP Requests with useEffect (JSONPlaceholder Practice)
Experience the actual API call flow and learn that useEffect is a "side effect that runs after rendering."
Implement the basic pattern of loading data with fetch/axios and managing loading, success, and error states.

🟩 Dark Mode Toggle — Synchronizing body class with useEffect(…, [dark])
Use the dependency array of useEffect to synchronize external environment (DOM) with React state.
Automatically update body.classList whenever the state value changes
to learn a structure where React controls even the actual HTML state.

🟦 Sending HTTP Requests with useEffect (JSONPlaceholder Practice)
Experience the actual API call flow and learn that useEffect is a "side effect that runs after rendering."
Implement the basic pattern of fetching data with fetch/axios and managing loading, success, and error states.

🟩 Mission X — Request Cancellation & Advanced Error Handling + axios Instance Practical Patterns
When components disappear during API calls or rapid consecutive requests come in
Learn practical patterns for safely canceling requests using AbortController and axios cancel tokens.
Also learn how to apply common error handling logic to axios instances to reduce duplication.

🟩 Mission Y — Creating a Reusable Data Fetching Hook: useFetchProducts
Abstract the asynchronous processing patterns learned so far into a custom hook (useFetch).
Create a structure that integrates data loading, errors, and result values management, and can be easily reused in any component.
Experience production-level React code reusability and scalability.

Pre-enrollment Reference Information

Practice Environment

💻 If Node.js (v18 or higher) is installed, you can practice directly in your local environment
🌐 You can also practice using just a browser on CodeSandbox and similar platforms
🪶 Basic knowledge of HTML·CSS·JS syntax is sufficient (complete beginners are also OK)
🧩 Every section is structured in the order of "Concept → Visualization → Practice → Mission"
📘 All lecture PDF learning materials provided (including concept summaries + mission explanations)
🧠 Focus on "directly executing and observing results" rather than theory
🧰 Includes examples based on Visual Studio Code / Vite
⚡️ Explains React's "operating principles" rather than just its "appearance"

📘 Learning Materials

  • 🧾 Lecture PDF Materials

    • Summary of Key Concepts by Section

    • JSX, state, useEffect, rendering flow and other step-by-step visual materials

    • Code snippets + commentary explanations + DevTools screenshots included

    • Includes review mini-quizzes and "Key Summary Checklist"

  • 💻 Example Project Code (ZIP)

    • Section 1~10 Complete Examples + Answer Code for Each Mission

    • Organized by structure with annotations, optimized for practice review

  • 🧩 Additional Practice Mission PDF

    • Bonus assignments where you can immediately apply the concepts from each section

    • DOM Structure, Render Tree, and Event Flow Observation Practice Problems Included

Recommended for
these people

Who is this course right for?

  • Beginner developers learning React for the first time

  • Frontend beginner who has only worked with HTML/CSS/JS

  • Someone with existing React experience but unclear concepts

  • People who want to develop their component design sense

  • People who want to logically understand React's internal working principles

  • Backend/Full-stack developer looking to transition to a frontend career

  • Someone who thought JSX syntax was just a simple HTML extension

  • React Hooks (useState/useEffect) prospective learner preparing for study

  • People who have experienced 'rendering loops' or 'state tangling' while working on React projects

  • People who want to 'design' React, not just simply use it

  • A person who aims to build a design system

  • Someone who wants to view React as a "rendering engine" rather than a "library"

  • Someone who wants to build structural understanding while debugging React code

  • People who want to clearly understand the relationship between useState, props, and rendering timing

  • People who want to broaden their understanding of component-based UI frameworks in general (Vue, Svelte, etc.)

  • College students and non-majors learning React

  • Existing frontend developers who want to clearly articulate the "React philosophy"

  • Aspiring developers preparing for interviews or building portfolios

  • A person learning frontend architecture for the first time

Need to know before starting?

  • Basic Understanding of HTML and DOM Structure

  • Basic CSS writing skills

  • JavaScript Basics

Hello
This is

441

Learners

28

Reviews

10

Answers

4.7

Rating

12

Courses

안녕하세요, 우리동네코딩 스튜디오에 오신 것을 환영합니다!

우리동네코딩 스튜디오는 카네기 멜론, 워싱턴, 토론토, 워터루 등 북미의 주요 대학에서 컴퓨터공학을 전공하고, Google, Microsoft, Meta 등 글로벌 IT 기업에서 실무 경험을 쌓은 개발자들이 함께 만든 교육 그룹입니다.

처음에는 미국과 캐나다의 컴퓨터공학 전공자들끼리 함께 공부하며 성장하고자 만든 스터디 모임에서 시작되었습니다. 각기 다른 대학, 다른 시간대에 있었지만 함께 문제를 해결하고 서로에게 배운 그 시간은 매우 특별했고, 자연스럽게 이런 생각이 들었습니다.

“우리가 공부하던 이 방식, 그대로 다른 사람에게도 전하면 어떨까?”

그 물음이 바로 우리동네코딩 스튜디오의 출발점이었습니다.

현재는 약 30명의 현직 개발자와 컴퓨터공학 전공 대학생들이 각자의 전문 분야를 맡아, 입문부터 실전까지 아우르는 커리큘럼을 직접 설계하고 강의합니다. 단순한 지식 전달을 넘어, 진짜 개발자의 시선으로 배우고 함께 성장할 수 있는 환경을 제공합니다.

“진짜 개발자는, 진짜 개발자에게 배워야 합니다.”

저희는 웹 개발의 전 과정을 처음부터 끝까지 체계적으로 다루되, 이론에 머무르지 않고 실습과 실전 중심의 피드백을 통해 실력을 키워드립니다.
수강생 한 사람, 한 사람의 성장을 함께 고민하고 이끌어가는 것이 우리의 철학입니다.

🎯 우리의 철학은 분명합니다.
"진정한 배움은 실천에서 오고, 성장은 함께할 때 완성된다."

개발을 처음 시작하는 입문자부터, 실무 능력을 키우고 싶은 취업 준비생, 진로를 탐색 중인 청소년까지.
우리동네코딩 스튜디오는 모두의 출발점이자, 함께 걷는 든든한 동반자가 되고자 합니다.

이제, 혼자 고민하지 마세요.
우리동네코딩 스튜디오가 여러분의 성장을 함께하겠습니다.


Welcome to Neighborhood Coding Studio!

Neighborhood Coding Studio was founded by a team of developers who studied computer science at top North American universities such as Carnegie Mellon, the University of Washington, the University of Toronto, and the University of Waterloo, and went on to gain hands-on experience at global tech companies like Google, Microsoft, and Meta.

It all began as a study group formed by computer science students across the U.S. and Canada, created to grow together by sharing knowledge, solving problems, and learning from one another.
Though we were attending different schools in different time zones, the experience was so meaningful that it led us to one simple thought:

“What if we shared this way of learning with others?”

That thought became the foundation of Neighborhood Coding Studio.

Today, we are a team of around 30 active developers and computer science students, each taking responsibility for their area of expertise—designing and delivering a curriculum that spans from foundational knowledge to real-world development.
We’re not just here to teach—we’re here to help you see through the lens of real developers and grow together.

“To become a real developer, you must learn from real developers.”

Our courses take you through the entire web development journey—from start to finish—focused on hands-on practice, real-world projects, and practical feedback.
We care deeply about each learner’s growth and are committed to supporting your path every step of the way.

🎯 Our philosophy is simple but powerful:
"True learning comes from doing, and true growth happens together."

Whether you're just getting started, preparing for your first job, or exploring your future in tech,
Neighborhood Coding Studio is here to be your launchpad—and your trusted companion on the journey.

You don’t have to do it alone.
Let Neighborhood Coding Studio walk with you toward your future in development.

Curriculum

All

102 lectures ∙ (4hr 16min)

Course Materials:

Lecture resources
Published: 
Last updated: 

Reviews

All

2 reviews

5.0

2 reviews

  • Su Yeoun Lee님의 프로필 이미지
    Su Yeoun Lee

    Reviews 21

    Average Rating 5.0

    5

    71% enrolled

    정의를 명확히 설명을 해주어서 개념을 이해시켜줍니다. 특히 설명에 군더더기가 없어 시간 낭비가 없습니다. 그리고 각 세션의 끝에 [필독]을 두어 한번 더 리마인드할 수 있게 정리해주는 것도 좋았습니다. 강의를 듣다 보면 느껴지는게 강사님이 가르치는데 진심이다는 것이 느껴집니다. 리엑트를 배우려는 분들께 강추합니다. 후회는 없을 겁니다.

    • nhcodingstudio님의 프로필 이미지
      nhcodingstudio

      Reviews 1

      Average Rating 5.0

      5

      85% enrolled

      Limited time deal

      $19,360.00

      60%

      $37.40

      nhcodingstudio's other courses

      Check out other courses by the instructor!

      Similar courses

      Explore other courses in the same field!