Next.js course · Module 1: Next.js Configuration

Component System - Client and Server Components

13 min read ·
In this lesson10

In Quantum Metropolis, quantum system architects always have to make fundamental decisions: which processes to run on central quantum processors (for tasks requiring the highest computational power), and which on citizens' end devices (for instant interactivity). This dichotomy perfectly reflects the revolutionary change that the App Router introduced in Next.js 13 and that Next.js 16 develops further - the division into Server Components and Client Components.

The React Server Components Revolution

React Server Components (RSC) represent the biggest paradigm shift in React since the introduction of Hooks. Before their appearance, all React components were rendered on the server or client as a cohesive whole. Now we can create applications where some components are rendered exclusively on the server, others on the client, and data and UI structures flow seamlessly between them.

It's like the difference between traditional transport systems in Quantum Metropolis, where vehicles move only along specific routes, and the new quantum transport system, where matter can be teleported directly to its destination.

Server Components - Basics

In the App Router of Next.js 16, all components are Server Components by default, unless we explicitly mark them as Client Components.

Server Components are rendered on the server and don't send any JavaScript to the browser. It's like the quantum computing processors of Quantum Metropolis, which perform complex calculations and transmit only the final results to citizens' devices.

Advantages of Server Components:

  1. Access to server resources - direct access to databases, file system, and other server resources
  2. Security - sensitive data and logic remain on the server
  3. Automatic code splitting - only necessary code is sent to the client
  4. Smaller JavaScript bundle size - no need to send rendering code
  5. Better SEO - faster static rendering
  6. Better first load performance - less JavaScript to download and execute

Server Component Example:

// app/dashboard/stats/page.tsx - Server Component (by default)
export default async function StatsPage() {
  // This code runs ONLY on the server
  const stats = await fetchQuantumSystemStats();

  return (
    <section className="quantum-stats">
      <h1>Quantum Systems Statistics</h1>
      <div className="stats-grid">
        {stats.map(stat => (
          <StatCard key={stat.id} name={stat.name} value={stat.value} />
        ))}
      </div>
    </section>
  );
}

Note several important aspects:

  1. Using async/await directly in the component - this is only possible in Server Components
  2. No use of React hooks (useState, useEffect, etc.) - they are not available in Server Components
  3. No event handling - Server Components cannot handle user events

Client Components - Basics

Client Components provide interactivity: on the first visit Next.js pre-renders them to HTML on the server, then they are hydrated in the browser and keep running on the client. To mark a component as a Client Component, we add the "use client" directive at the top of the file.

This process is called hydration: in the browser, React attaches event handlers to the HTML that was rendered on the server earlier. Only after hydration do buttons respond to clicks, and useEffect effects run after it.

It's like the personal quantum devices of Quantum Metropolis citizens - lighter, but instantly responsive to user actions.

Advantages of Client Components:

  1. Interactivity - handling user events (clicks, text input, etc.)
  2. React hooks - ability to use useState, useEffect, useContext, and other hooks
  3. Access to browser APIs - window, document, localStorage, etc.
  4. Client-side effects - animations, real-time interactions

Client Component Example:

// app/dashboard/interactive-controls.tsx
"use client"; // This directive marks the client component

import { useState, useEffect } from 'react';

export default function InteractiveControls() {
  // This code runs in the user's browser
  const [activeSystem, setActiveSystem] = useState('energy');
  const [status, setStatus] = useState('idle');

  useEffect(() => {
    // Effects run only on the client
    const timer = setTimeout(() => {
      setStatus('ready');
    }, 1000);

    return () => clearTimeout(timer);
  }, []);

  return (
    <div className="control-panel">
      <h2>System: {activeSystem}</h2>
      <p>Status: {status}</p>
      <div className="button-group">
        <button onClick={() => setActiveSystem('transport')}>
          Transport
        </button>
        <button onClick={() => setActiveSystem('energy')}>
          Energy
        </button>
        <button onClick={() => setActiveSystem('security')}>
          Security
        </button>
      </div>
    </div>
  );
}

Key aspects:

  1. The "use client" directive at the beginning of the file
  2. Using React hooks (useState, useEffect)
  3. Event handling (onClick)

Combining Server and Client Components

The most powerful feature of the new model is the ability to combine Server and Client Components in a single application. Server Components can render Client Components, but not the other way around (with some exceptions using patterns). It's like the hybrid transport system of Quantum Metropolis, where main routes are served by quantum teleportation, and the last mile by personal vehicles.

Example of combining components:

// app/dashboard/page.tsx - Server Component
export default async function DashboardPage() {
  // This code runs ONLY on the server
  const dashboardData = await fetchDashboardData();

  return (
    <main className="quantum-dashboard">
      <h1>Quantum Metropolis Control Panel</h1>

      {/* Server Component */}
      <SystemStatusPanel systemsData={dashboardData.systems} />

      {/* Client Component (imported and used in Server Component) */}
      <InteractiveControls />
    </main>
  );
}
// app/dashboard/system-status-panel.tsx - Server Component (by default)
export default function SystemStatusPanel({ systemsData }) {
  return (
    <div className="system-status-panel">
      <h2>System Status</h2>
      <div className="status-grid">
        {systemsData.map(system => (
          <SystemStatusCard key={system.id} system={system} />
        ))}
      </div>
    </div>
  );
}
// app/dashboard/system-status-card.tsx - Server Component (by default)
import { StatusIndicator } from './status-indicator';

export default function SystemStatusCard({ system }) {
  return (
    <div className="status-card">
      <h3>{system.name}</h3>
      <p>Performance: {system.performance}%</p>

      {/* Client Component used in Server Component */}
      <StatusIndicator status={system.status} />
    </div>
  );
}
// app/dashboard/status-indicator.tsx - Client Component
"use client";

import { useState, useEffect } from 'react';

export function StatusIndicator({ status }) {
  const [blinking, setBlinking] = useState(false);

  useEffect(() => {
    const interval = setInterval(() => {
      setBlinking(prev => !prev);
    }, 500);

    return () => clearInterval(interval);
  }, []);

  return (
    <div className={`status-indicator ${status} ${blinking ? 'blink' : ''}`}>
      {status === 'active' ? 'Active' : 'Inactive'}
    </div>
  );
}

Optimization Strategies When Designing Components

Properly deciding which components should be Server Components and which should be Client Components is crucial for application performance. Here are some strategies to help you make these decisions:

1. Server Component as the Default Choice

Always start with Server Components unless you need features available only in Client Components. This is similar to the approach in Quantum Metropolis, where central computing units are used by default unless instant interactivity is needed.

2. Granular Interactivity

Instead of marking an entire large component as "use client", extract only the interactive parts into separate Client Components, leaving the rest as Server Components.

Before optimization:

// LESS OPTIMAL - entire component is a Client Component
"use client";
import { useState } from 'react';

export default function ControlPanel() {
  const [activeTab, setActiveTab] = useState('overview');

  return (
    <div className="control-panel">
      <h2>Control Panel</h2>
      <p>This panel allows you to manage quantum systems.</p>

      <div className="tabs">
        <button onClick={() => setActiveTab('overview')}>Overview</button>
        <button onClick={() => setActiveTab('settings')}>Settings</button>
      </div>

      <div className="tab-content">
        {activeTab === 'overview' ? (
          <OverviewContent /> // Lots of static content
        ) : (
          <SettingsContent /> // Lots of static content
        )}
      </div>
    </div>
  );
}

After optimization:

// BETTER - split into Client and Server Components

// control-panel.tsx - Server Component
import { TabController } from './tab-controller';
import { OverviewContent } from './overview-content';
import { SettingsContent } from './settings-content';

export default function ControlPanel() {
  return (
    <div className="control-panel">
      <h2>Control Panel</h2>
      <p>This panel allows you to manage quantum systems.</p>

      {/* Only TabController is a Client Component; the tab contents stay on the server */}
      <TabController overview={<OverviewContent />} settings={<SettingsContent />} />
    </div>
  );
}

// tab-controller.tsx - Client Component
"use client";
import { useState, type ReactNode } from 'react';

export function TabController({ overview, settings }: { overview: ReactNode; settings: ReactNode }) {
  const [activeTab, setActiveTab] = useState('overview');

  return (
    <>
      <div className="tabs">
        <button onClick={() => setActiveTab('overview')}>Overview</button>
        <button onClick={() => setActiveTab('settings')}>Settings</button>
      </div>

      <div className="tab-content">
        {activeTab === 'overview' ? overview : settings}
      </div>
    </>
  );
}

A component imported in a file with "use client" becomes a Client Component too. That is why the Server Component ControlPanel imports OverviewContent and SettingsContent and passes them to TabController as props, just like children.

3. "Container and Presentation" Pattern

Use Server Components as "containers" for fetching data and organization, and Client Components as "presentation components" responsible for interactivity.

// products-container.tsx - Server Component (container)
export default async function ProductsContainer() {
  const products = await fetchProducts();

  return <ProductsList products={products} />;
}

// products-list.tsx - Client Component (presentation)
"use client";
import { useState } from 'react';

export function ProductsList({ products }) {
  const [sortBy, setSortBy] = useState('name');
  const sortedProducts = [...products].sort((a, b) =>
    sortBy === 'price' ? a.price - b.price : a.name.localeCompare(b.name)
  );

  return (
    <div>
      <div className="sorting">
        <button onClick={() => setSortBy('name')}>Sort by name</button>
        <button onClick={() => setSortBy('price')}>Sort by price</button>
      </div>

      <ul className="products">
        {sortedProducts.map(product => (
          <li key={product.id}>{product.name} - {product.price}</li>
        ))}
      </ul>
    </div>
  );
}

Data Flow Between Server and Client Components

Passing data between server and client requires a special approach. In the RSC model, props flow down the component tree from server to client; in the other direction the client sends data by calling Server Actions (you will meet them in a moment). It's like quantum channels in Quantum Metropolis - orders flow from the central hub to personal devices, and reports come back through a separate channel.

Passing Data to Client Components:

// server-component.tsx - Server Component
async function ServerComponent() {
  const data = await fetchSensitiveData();

  // Pass processed data to client
  return <ClientComponent processedData={data.publicPart} />;
}

// client-component.tsx - Client Component
"use client";

export function ClientComponent({ processedData }) {
  // Using data passed from the server
  return <div>{processedData.map(item => <p key={item.id}>{item.name}</p>)}</div>;
}

Handling User Actions from Client Components:

When a Client Component needs to perform an action that involves the server, we use Server Actions or Route Handlers (route.ts files; in the Pages Router their counterpart is API Routes).

Using Server Actions (stable since Next.js 14):

// actions.js - Server Actions
"use server";

export async function updateSystemStatus(systemId, newStatus) {
  // This function runs on the server
  await database.systems.update(systemId, { status: newStatus });
  return { success: true };
}

// client-component.tsx - Client Component
"use client";
import { useState } from 'react';
import { updateSystemStatus } from './actions';

export function StatusToggle({ systemId, initialStatus }) {
  const [status, setStatus] = useState(initialStatus);

  async function handleToggle() {
    const newStatus = status === 'active' ? 'inactive' : 'active';
    const result = await updateSystemStatus(systemId, newStatus);

    if (result.success) {
      setStatus(newStatus);
    }
  }

  return (
    <button onClick={handleToggle}>
      {status === 'active' ? 'Deactivate' : 'Activate'}
    </button>
  );
}

Differences in Reloading and Navigation

In the traditional React model, page reloading or navigation often meant restarting the entire application. In the React Server Components model, navigation is more optimal:

  • Server Components are re-rendered on the server during navigation
  • Client Components in shared layouts keep their state during navigation; components of the page you leave are unmounted by default
  • Page transitions are smoother thanks to the "instant navigation" mechanism

It's like the advanced quantum switches in Quantum Metropolis - they allow instant transitions between different layouts without interrupting system operations.

Common Mistakes and Pitfalls

1. Using React hooks in Server Components

// WRONG - Server Component trying to use React hooks
export default function ServerComponent() {
  // This will cause an error!
  const [count, setCount] = useState(0);

  return <div>Count: {count}</div>;
}

2. Attempting to access browser APIs in Server Components

// WRONG - Server Component trying to use browser APIs
export default function ServerComponent() {
  // This will cause an error! (ReferenceError: window is not defined)
  const windowWidth = window.innerWidth;

  return <div>Width: {windowWidth}px</div>;
}

3. Passing functions from Server Components to Client Components

// WRONG - Server Component passes a regular function to a Client Component
// app/page.tsx (Server Component)
import ClientButton from './client-button';

export default function Page() {
  const handleClick = () => console.log("Clicked!");

  // This won't work! Props passed to a Client Component must be serializable
  return <ClientButton onClick={handleClick} />;
}

Server Actions are the exception: you can pass a function marked with "use server" to a Client Component.

Advanced Patterns for Using Server and Client Components

1. Provider Pattern

If you need to share state between different Client Components, use a Client Provider at a high level. This is similar to central synchronization units in Quantum Metropolis, which coordinate the actions of different personal devices.

// providers.tsx - Client Component
"use client";
import { createContext, useState } from 'react';

export const ThemeContext = createContext({ theme: 'light', toggleTheme: () => {} });

export function ThemeProvider({ children }) {
  const [theme, setTheme] = useState('light');
  const toggleTheme = () => setTheme(prev => prev === 'light' ? 'dark' : 'light');

  return (
    <ThemeContext.Provider value={{ theme, toggleTheme }}>
      {children}
    </ThemeContext.Provider>
  );
}
// layout.tsx - Server Component
import { ThemeProvider } from './providers';

export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html>
      <body>
        <ThemeProvider>
          {children}
        </ThemeProvider>
      </body>
    </html>
  );
}

2. "Lifting State Up" Pattern

When you have several Client Components that need access to the same state, lift the state to a common Client Component ancestor, not to a Server Component.

// parent.tsx - Server Component
export default function ParentServerComponent() {
  return <ClientParent />;
}

// client-parent.tsx - Client Component (common ancestor)
"use client";
import { useState } from 'react';

export function ClientParent() {
  const [sharedState, setSharedState] = useState('initial');

  return (
    <div>
      <ClientChildA sharedState={sharedState} setSharedState={setSharedState} />
      <ClientChildB sharedState={sharedState} />
    </div>
  );
}

3. Strategic Use of Suspense

Use the Suspense component to manage loading states in a hybrid application:

// page.tsx - Server Component
import { Suspense } from 'react';

export default function Page() {
  return (
    <div>
      <h1>Quantum Metropolis System Data</h1>

      <Suspense fallback={<div>Loading data...</div>}>
        <AsyncDataComponent />
      </Suspense>
    </div>
  );
}

// async-data-component.tsx - Server Component with asynchronous code
async function AsyncDataComponent() {
  // This component can be suspended during loading
  const data = await fetchData();

  return <div>{/* Rendering data */}</div>;
}

Summary

The component system in Next.js 16 based on React Server Components is a revolutionary change that combines the advantages of server rendering with client-side interactivity. Just as in Quantum Metropolis, where quantum teleportation and personal vehicles create a hybrid transport system, in Next.js server and client components work together, creating an efficient, scalable, and user-friendly interface.

When designing Next.js 16 applications:

  1. Use Server Components by default for better performance and security
  2. Switch to Client Components only when you need interactivity, hooks, or browser APIs
  3. Split components granularly to minimize the amount of JavaScript sent to the client
  4. Remember the direction of props - from server to client (you send data the other way with Server Actions)
  5. Use Server Actions for form processing and other user actions

Proper use of Server and Client Components will allow you to create next-generation Next.js applications that combine fast loading, SEO performance, and rich user interfaces - without the compromises that were necessary in traditional React applications.

In the next lesson, we will move to practice and create our first "Hello World" application using Next.js 16 and App Router, where we'll apply the knowledge gained about Server and Client Components.

Code for this lesson: App.tsx
// Hooks - useState and useEffect - Metropolis Quantum
import React, { useState, useEffect } from 'react';

console.log("React Hooks - useState and useEffect");
console.log("Quantum Systems Management\n");

// ==========================================
// 1. useState - State Management
// ==========================================

function QuantumReactor() {
  const [temperature, setTemperature] = useState<number>(20);
  const [pressure, setPressure] = useState<number>(100);
  const [status, setStatus] = useState<'stable' | 'warning' | 'critical'>('stable');

  // useEffect - monitor temperature and pressure changes
  useEffect(() => {
    console.log(`Temperature: ${temperature}°C, Pressure: ${pressure} kPa`);

    // Determine status based on values
    if (temperature > 80 || pressure > 150) {
      setStatus('critical');
    } else if (temperature > 60 || pressure > 120) {
      setStatus('warning');
    } else {
      setStatus('stable');
    }
  }, [temperature, pressure]); // Called when temperature or pressure change

  const getStatusColor = () => {
    switch(status) {
      case 'stable': return '#4caf50';
      case 'warning': return '#ff9800';
      case 'critical': return '#f44336';
    }
  };

  return (
    <div style={{
      background: 'rgba(255, 255, 255, 0.1)',
      padding: '20px',
      borderRadius: '12px',
      border: `2px solid ${getStatusColor()}`
    }}>
      <h2 style={{ color: getStatusColor() }}>
        Quantum Reactor - {status.toUpperCase()}
      </h2>

      <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '20px', marginTop: '20px' }}>
        <div>
          <h4>Temperature: {temperature}°C</h4>
          <input
            type="range"
            min="0"
            max="100"
            value={temperature}
            onChange={(e) => setTemperature(Number(e.target.value))}
            style={{ width: '100%' }}
          />
        </div>

        <div>
          <h4>Pressure: {pressure} kPa</h4>
          <input
            type="range"
            min="50"
            max="200"
            value={pressure}
            onChange={(e) => setPressure(Number(e.target.value))}
            style={{ width: '100%' }}
          />
        </div>
      </div>
    </div>
  );
}

// ==========================================
// 2. useEffect - Side Effects
// ==========================================

function QuantumClock() {
  const [time, setTime] = useState<Date>(new Date());
  const [quantumTime, setQuantumTime] = useState<number>(0);

  // useEffect for clock - runs after component mounts
  useEffect(() => {
    console.log("Quantum Clock initiated");

    const interval = setInterval(() => {
      setTime(new Date());
      setQuantumTime(prev => prev + 1);
    }, 1000);

    // Cleanup function - called on unmount
    return () => {
      console.log("Quantum Clock stopped");
      clearInterval(interval);
    };
  }, []); // Empty array = run once after mounting

  return (
    <div style={{
      background: 'rgba(124, 77, 255, 0.2)',
      padding: '20px',
      borderRadius: '12px',
      textAlign: 'center'
    }}>
      <h3 style={{ color: '#7c4dff' }}>Quantum Time Portal</h3>
      <div style={{ fontSize: '2rem', margin: '20px 0', color: '#64ffda' }}>
        {time.toLocaleTimeString()}
      </div>
      <div style={{ color: '#b0bec5' }}>
        Quantum Seconds: {quantumTime}
      </div>
    </div>
  );
}

// ==========================================
// 3. Multiple useEffect Hooks
// ==========================================

function DataMonitor() {
  const [data, setData] = useState<number[]>([]);
  const [average, setAverage] = useState<number>(0);
  const [trend, setTrend] = useState<'up' | 'down' | 'stable'>('stable');

  // Effect 1: Generate new data every second
  useEffect(() => {
    const interval = setInterval(() => {
      const newValue = Math.floor(Math.random() * 100);
      setData(prev => [...prev.slice(-9), newValue]); // Keep the last 10 values
    }, 1000);

    return () => clearInterval(interval);
  }, []);

  // Effect 2: Calculate average when data changes
  useEffect(() => {
    if (data.length > 0) {
      const avg = data.reduce((a, b) => a + b, 0) / data.length;
      setAverage(avg);
      console.log(`New average: ${avg.toFixed(2)}`);
    }
  }, [data]);

  // Effect 3: Determine trend
  useEffect(() => {
    if (data.length >= 2) {
      const lastTwo = data.slice(-2);
      if (lastTwo[1] > lastTwo[0]) setTrend('up');
      else if (lastTwo[1] < lastTwo[0]) setTrend('down');
      else setTrend('stable');
    }
  }, [data]);

  const getTrendIcon = () => {
    switch(trend) {
      case 'up': return '▲';
      case 'down': return '▼';
      case 'stable': return '→';
    }
  };

  return (
    <div style={{
      background: 'rgba(255, 255, 255, 0.1)',
      padding: '20px',
      borderRadius: '12px'
    }}>
      <h3 style={{ color: '#64ffda' }}>Data Stream Monitor</h3>

      <div style={{ display: 'flex', gap: '5px', marginTop: '15px', height: '100px', alignItems: 'flex-end' }}>
        {data.map((value, index) => (
          <div
            key={index}
            style={{
              flex: 1,
              height: `${value}%`,
              background: 'linear-gradient(to top, #7c4dff, #64ffda)',
              borderRadius: '4px 4px 0 0'
            }}
          />
        ))}
      </div>

      <div style={{ marginTop: '20px', display: 'flex', justifyContent: 'space-around' }}>
        <div>
          <div style={{ color: '#b0bec5', fontSize: '0.9rem' }}>Average</div>
          <div style={{ color: '#64ffda', fontSize: '1.5rem', fontWeight: 'bold' }}>
            {average.toFixed(1)}
          </div>
        </div>
        <div>
          <div style={{ color: '#b0bec5', fontSize: '0.9rem' }}>Trend</div>
          <div style={{ fontSize: '1.5rem' }}>
            {getTrendIcon()}
          </div>
        </div>
      </div>
    </div>
  );
}

// ==========================================
// Main App
// ==========================================
function App() {
  useEffect(() => {
    console.log("Quantum Systems Dashboard initialized");
  }, []);

  return (
    <div style={{
      padding: '20px',
      background: 'linear-gradient(135deg, #0f0f23 0%, #1a1a2e 100%)',
      minHeight: '100vh',
      color: 'white'
    }}>
      <h1 style={{ textAlign: 'center', color: '#64ffda' }}>
        React Hooks - useState & useEffect
      </h1>

      <div style={{ display: 'grid', gap: '20px', marginTop: '30px' }}>
        <QuantumReactor />
        <QuantumClock />
        <DataMonitor />
      </div>

      <div style={{
        marginTop: '30px',
        background: 'rgba(100, 255, 218, 0.1)',
        padding: '20px',
        borderRadius: '10px',
        borderLeft: '4px solid #64ffda'
      }}>
        <h3>useEffect Tips:</h3>
        <ul style={{ lineHeight: '1.8' }}>
          <li>[] (empty array) = run once after mounting</li>
          <li>[dep1, dep2] = run when dependencies change</li>
          <li>No array = run after every render</li>
          <li>Return function = cleanup before unmounting</li>
          <li>You can have multiple useEffects in a component</li>
        </ul>
      </div>
    </div>
  );
}

export default App;

Docs entries used in this lesson

Spotted a mistake in this lesson?

Check yourself

Answer the questions from this lesson. Pick an answer to see right away whether it is correct.

  1. 1. Props in React are:

  2. 2. State in React is:

  3. 3. The useState hook is used for:

Hands-on tasks in the game

  • Code editor

    Create an async Server Component ImplantDashboard (export default). Above the component, define an async function getImplants() that returns an array of 3 implants shaped { id, name, status }. In the component, fetch the data with const implants = await getImplants(), then display them in a <ul>: each implant as an <li key={implant.id}> with its name and status.

  • Code editor

    Create a Client Component NeuralVisualizer (export default): add 'use client' at the top of the file, keep the activity in useState (a boolean, false at first), add an "Activate Neural Link" button that changes the state, and display "Status: ACTIVE" or "Status: INACTIVE".

  • Click in order

    Arrange the syntax for exporting a Server Component in Next.js

  • Code editor

    Create a Greeting component that accepts a 'name' prop and displays a personalized welcome message

  • Vertical ordering

    Arrange the steps of SSR page rendering in Next.js

  • Code editor

    Create a Counter component that displays a counter (useState, initial value 0) and a button that increases the counter by 1 on each click.

  • Click in order

    Arrange the syntax for destructuring the useState hook

  • Code editor

    Create a HolographicInterface component: export a default function that returns a div with class 'dashboard-panel', an h1 heading 'Next.js Dashboard', and a paragraph with system status.

  • Code editor

    Create a login page component LoginPage (export default). Add 'use client' at the top of the file. Return a <form> with an email field (<input type="email">), a password field (<input type="password">) and a "Log in" button (<button type="submit">). In the onSubmit handler, call event.preventDefault() so the page does not reload.

  1. QuestionDefinition of Props in React
  2. QuestionDefinition of State in React
  3. Coding taskPractice: Server Component
  4. QuestionThe useState Hook in React
  5. Coding taskPractice: Client Component
  6. Click in orderServer Component Export
  7. Coding taskPractice: Component with Props
  8. Put in orderSSR Rendering Cycle
  9. Coding taskPractice: Counter with useState
  10. Click in orderuseState Destructuring
  11. Coding taskPractice: HolographicInterface Component
  12. Coding taskPractice: Login Component

Useful articles