// UserController.java
@RestController
@RequestMapping("/api/users")
public class UserController {
    @Autowired
    private UserService userService;
    
    @GetMapping("/{id}")
    public ResponseEntity<UserDTO> getUser(@PathVariable Long id) {
        return ResponseEntity.ok(userService.getUser(id));
    }
}

// 그리고 또...
// ProductController.java
@RestController
@RequestMapping("/api/products")
public class ProductController {
    @Autowired
    private ProductService productService;
    
    @GetMapping("/{id}")
    public ResponseEntity<ProductDTO> getProduct(@PathVariable Long id) {
        return ResponseEntity.ok(productService.getProduct(id));
    }
}

// 그리고 또... 그리고 또...

# 1976년의 자동화
# Makefile
app: main.o utils.o
    gcc -o app main.o utils.o

main.o: main.c
    gcc -c main.c

utils.o: utils.c
    gcc -c utils.c

' Visual Basic이 자동으로 생성한 코드
Private Sub Command1_Click()
    MsgBox "Hello, World!"
End Sub

Private Sub Form_Load()
    Command1.Caption = "Click Me"
    Command1.Left = 1200
    Command1.Top = 800
End Sub

# Rails의 마법 같은 코드 생성
$ rails generate scaffold Post title:string content:text

# 자동으로 생성되는 것들:
# - Model (post.rb)
# - Controller (posts_controller.rb)
# - Views (index, show, new, edit...)
# - Migration (create_posts.rb)
# - Routes
# - Tests

# Yeoman으로 React 앱 생성
$ npm install -g yo generator-react-webpack
$ yo react-webpack my-app

# 생성되는 것들:
# - 프로젝트 구조
# - 빌드 설정 (webpack.config.js)
# - 테스트 설정 (jest.config.js)
# - 린트 설정 (.eslintrc)
# - 패키지 의존성 (package.json)
# - README, gitignore 등

# 2016~현재: 제로 설정 철학
$ npx create-react-app my-app
$ npx create-next-app my-app
$ npm create vite@latest my-app
$ bun create next-app my-app

# 2024: AI 기반 생성
$ v0 create dashboard --with-auth --database=postgres

// Spring Framework의 마법
@RestController
public class UserController {
    @Autowired  // ← 이것은 메타프로그래밍
    private UserService userService;
    
    @GetMapping("/users/{id}")  // ← 이것도
    public User getUser(@PathVariable Long id) {
        return userService.getUser(id);
    }
}

// Spring이 런타임에 하는 일:
// 1. @RestController 발견
// 2. HTTP 요청 핸들러로 등록
// 3. @Autowired 발견
// 4. UserService 인스턴스 자동 주입
// 5. @GetMapping 발견
// 6. GET /users/{id} 라우트 자동 생성

// Rust의 derive 매크로
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct User {
    pub id: u64,
    pub name: String,
    pub email: String,
}

// 자동으로 생성되는 코드:
// - Debug 출력 구현
// - Clone 구현
// - JSON 직렬화/역직렬화 구현
// 수백 줄의 보일러플레이트를 한 줄로!

# Django ORM의 메타클래스 마법
class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField()
    
    class Meta:
        db_table = 'users'
        ordering = ['-created_at']

# Django가 metaclass로 자동 생성하는 것들:
# - __init__ 메서드
# - save(), delete() 메서드
# - objects.all(), filter() 같은 쿼리 메서드
# - 데이터베이스 마이그레이션 코드

// Vue 3의 반응성 시스템
const state = reactive({
  count: 0,
  message: 'Hello'
});

// state.count를 읽거나 쓸 때마다
// Vue가 자동으로 의존성 추적 및 UI 업데이트

// 내부 구현 (단순화)
function reactive(target) {
  return new Proxy(target, {
    get(obj, prop) {
      track(obj, prop);  // 의존성 추적
      return obj[prop];
    },
    set(obj, prop, value) {
      obj[prop] = value;
      trigger(obj, prop);  // UI 업데이트 트리거
      return true;
    }
  });
}

-- 개발자: 복잡한 SQL 작성
SELECT 
  o.order_id,
  c.customer_name,
  SUM(oi.quantity * p.price) as total
FROM orders o
JOIN customers c ON o.customer_id = c.id
JOIN order_items oi ON o.id = oi.order_id
JOIN products p ON oi.product_id = p.id
WHERE o.created_at >= '2024-01-01'
GROUP BY o.order_id, c.customer_name
HAVING total > 1000;

-- Access 사용자: 마우스 클릭으로 쿼리 작성

// 개발자가 작성해야 했던 코드:
const express = require('express');
app.post('/webhook/gmail', async (req, res) => {
  const email = req.body;
  if (email.from.includes('important')) {
    await slack.post('/messages', {
      channel: '#urgent',
      text: `New email from ${email.from}: ${email.subject}`
    });
  }
  res.status(200).send('OK');
});

// Zapier 사용자: 마우스 클릭 3번
// 1. Trigger: Gmail - New Email
// 2. Filter: From contains "important"
// 3. Action: Slack - Send Message to Channel

// 개발자가 작성해야 했던 코드:
// - React 컴포넌트 수십 개
// - API 호출 로직
// - 폼 검증
// - 테이블 페이지네이션
// - 권한 관리
// → 보통 2-3주 소요

// Retool: 2-3시간
// 1. DB 연결 (PostgreSQL, MySQL 등)
// 2. 쿼리 작성 (SQL Editor)
// 3. 테이블/폼/차트 컴포넌트 배치
// 4. 버튼에 쿼리 연결
// → 완료!

사용자: "사용자 목록을 보여주는 테이블 만들어줘. 
        검색 기능이 있고, 페이지네이션 되어야 해."

v0.dev: (3초 후)

// 자동 생성된 코드
'use client';

import { useState } from 'react';
import { Input } from '@/components/ui/input';
import {
  Table,
  TableBody,
  TableCell,
  TableHead,
  TableHeader,
  TableRow,
} from '@/components/ui/table';

export default function UserTable({ users }) {
  const [search, setSearch] = useState('');
  const [page, setPage] = useState(0);
  
  const filtered = users.filter(u => 
    u.name.toLowerCase().includes(search.toLowerCase())
  );
  
  const paged = filtered.slice(page * 10, (page + 1) * 10);
  
  return (
    <div className="space-y-4">
      <Input 
        placeholder="Search users..." 
        value={search}
        onChange={(e) => setSearch(e.target.value)}
      />
      <Table>
        <TableHeader>
          <TableRow>
            <TableHead>Name</TableHead>
            <TableHead>Email</TableHead>
          </TableRow>
        </TableHeader>
        <TableBody>
          {paged.map(user => (
            <TableRow key={user.id}>
              <TableCell>{user.name}</TableCell>
              <TableCell>{user.email}</TableCell>
            </TableRow>
          ))}
        </TableBody>
      </Table>
      {/* Pagination controls */}
    </div>
  );
}

문제별 최적 스택 설계:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
실시간 채팅?
  → WebSocket + Redis Pub/Sub
  → 또는 WebRTC Peer-to-Peer?

글로벌 서비스?
  → Multi-region DB + CDN
  → 또는 Edge Computing?

10억 건 데이터 분석?
  → Data Lake + Spark
  → 또는 Serverless 병렬 처리?

// ❌ 변화에 취약한 코드
function calculatePrice(productType: string, quantity: number): number {
  if (productType === 'book') {
    return quantity * 10000 * 0.9; // 10% 할인
  } else if (productType === 'electronics') {
    return quantity * 50000 * 0.95; // 5% 할인
  } else if (productType === 'food') {
    return quantity * 5000; // 할인 없음
  }
  // 새 제품 타입 추가할 때마다 이 함수 수정...
}

// ✅ 변화에 유연한 코드 (Strategy Pattern)
interface PricingStrategy {
  calculate(quantity: number): number;
}

class Product {
  constructor(
    private pricingStrategy: PricingStrategy
  ) {}
  
  getPrice(quantity: number): number {
    return this.pricingStrategy.calculate(quantity);
  }
}

// 새 제품 타입? 새 Strategy 클래스만 추가
// 기존 코드는 전혀 수정하지 않음 (Open-Closed Principle)