<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Turtle on Medium]]></title>
        <description><![CDATA[Stories by Turtle on Medium]]></description>
        <link>https://medium.com/@eheh34w?source=rss-e8494f8cfefc------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*epF0e3OROtGLTsKnyxjUNQ.jpeg</url>
            <title>Stories by Turtle on Medium</title>
            <link>https://medium.com/@eheh34w?source=rss-e8494f8cfefc------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 14:14:41 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@eheh34w/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[TypeScript, 10년 만에 JavaScript를 버리다]]></title>
            <link>https://eheh34w.medium.com/typescript-10%EB%85%84-%EB%A7%8C%EC%97%90-javascript%EB%A5%BC-%EB%B2%84%EB%A6%AC%EB%8B%A4-9c52e5b4f283?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/9c52e5b4f283</guid>
            <category><![CDATA[javascript]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[programming]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Thu, 26 Mar 2026 01:02:12 GMT</pubDate>
            <atom:updated>2026-03-26T01:02:12.603Z</atom:updated>
            <content:encoded><![CDATA[<h4>89초 걸리던 빌드가 8초가 된다. 그 시작이 6.0이다.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*FyijFpdNcadA_miAsNqIAQ.png" /></figure><p>VS Code의 150만 줄짜리 코드베이스를 빌드하는 데 89초가 걸린다. 곧 이게 8.74초로 줄어든다. <strong>10배.</strong></p><p>이건 TypeScript 7.0의 이야기다. 하지만 이 글의 주인공은 <strong>6.0</strong>이다.</p><p>2026년 3월 23일 정식 릴리즈된 TypeScript 6.0은 <strong>JavaScript로 작성된 마지막 TypeScript 컴파일러</strong>다. 7.0부터는 Go로 완전히 재작성된다. 6.0은 그 전환을 위한 다리 — 10년간 쌓인 레거시를 정리하고, 7.0이 갈 수 있는 길을 닦는 릴리즈다.</p><p>건너뛰면? 7.0 마이그레이션이 두 배로 고통스러워진다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*J_bfA6YYvRbPhVEAEGJwbw.png" /></figure><h3>무엇이 바뀌었나</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*gZAmjVBKznKWU4Ovhqs2pw.png" /></figure><h3>strict: true가 기본이다</h3><p>TypeScript 역사상 가장 큰 기본값 변경이다.</p><pre>// 5.x — strict는 꺼져 있었다<br>{ &quot;compilerOptions&quot;: { /* strict: false (기본) */ } }</pre><pre>// 6.0 — strict가 켜진다<br>{ &quot;compilerOptions&quot;: { /* strict: true (기본) */ } }</pre><p>strictNullChecks, noImplicitAny, strictFunctionTypes 등이 전부 켜진다. 이미 strict: true를 쓰고 있었다면 영향 없다. 아니었다면, 업그레이드 순간 수많은 타입 에러를 만나게 된다.</p><blockquote><em>당장 감당할 수 없다면 </em><em>&quot;strict&quot;: false를 명시적으로 추가하면 된다. 하지만 7.0에서는 이마저도 사라질 수 있다.</em></blockquote><h3>기본값이 2026년으로 올라왔다</h3><p>ES3가 기본이었다는 게 믿기지 않을 수 있다. 10년 넘게 호환성을 위해 유지해온 기본값이 드디어 현실적으로 바뀌었다.</p><h3>esModuleInterop을 끌 수 없다</h3><pre>// 6.0에서 에러<br>{ &quot;compilerOptions&quot;: { &quot;esModuleInterop&quot;: false } }  // ❌</pre><p>이걸 끄면 CJS↔ESM import에서 미묘한 런타임 버그가 발생했다. 6.0에서는 안전한 동작이 항상 켜진다.</p><h3>rootDir 기본값이 바뀌었다 — 가장 당황할 변경</h3><pre>// 5.x — rootDir 미설정 시<br>src/index.ts → dist/index.js  ✅</pre><pre>// 6.0 — rootDir 미설정 시<br>src/index.ts → dist/src/index.js  😱</pre><p>이전에는 소스 파일의 공통 디렉터리를 자동 계산했지만, 6.0부터는 <strong>tsconfig.json 위치</strong>가 기본이다. &quot;rootDir&quot;: &quot;src&quot;를 명시하면 해결된다.</p><h3>Deprecated — 7.0에서 완전 제거될 것들</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oEWaaSeKO1d1Gm_dv68QGA.png" /></figure><h3>새로운 기능들</h3><h3>Temporal API 타입 지원</h3><p>JavaScript의 새로운 날짜/시간 API 타입이 들어왔다.</p><pre>const now = Temporal.Now.plainDateTimeISO();<br>const meeting = Temporal.PlainDateTime.from(&quot;2026-04-01T10:00:00&quot;);<br>const duration = now.until(meeting);</pre><p>런타임 폴리필이 필요하다. TypeScript는 타입만 제공한다.</p><h3>Map.getOrInsert</h3><pre>// before<br>if (!cache.has(key)) cache.set(key, []);<br>cache.get(key)!.push(value);</pre><pre>// after — 한 줄<br>cache.getOrInsert(key, []).push(value);</pre><h3>왜 Go인가? (왜 Rust가 아닌가?)</h3><p>커뮤니티에서 가장 많이 나온 질문이다. TypeScript 창시자 Anders Hejlsberg가 직접 답했다.</p><p><strong>Go를 선택한 이유:</strong></p><ul><li>TypeScript 컴파일러는 <strong>순환 참조가 많은 복잡한 데이터 구조</strong>에 의존한다. Go는 GC를 제공하면서 네이티브 바이너리를 생성한다.</li><li>JavaScript → Go로 <strong>1:1 포팅</strong>이 가능했다. Hejlsberg는 “plug and play replacement”라고 표현했다.</li><li>고루틴 + 공유 메모리로 <strong>멀티코어 병렬 타입 체킹</strong>이 가능하다.</li></ul><p><strong>Rust가 아닌 이유:</strong></p><ul><li>GC가 없어서 메모리 관리를 근본적으로 재설계해야 한다.</li><li>포팅이 아니라 처음부터 다시 작성해야 하고, 그건 <strong>“수년짜리 작업”</strong>이 된다.</li></ul><p>핵심은 <strong>실용적 선택</strong>이었다. 가장 빠르게 10x를 달성할 수 있는 길.</p><h3>벤치마크</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*dceJqPUP_DAJt18b1trBDQ.png" /></figure><p>프로젝트 tsc (6.0) tsgo (7.0) 속도 향상 VS Code (150만 줄) 89초 8.74초 <strong>10.2x</strong> Sentry 133초 16초 <strong>8.3x</strong></p><p>타입 체킹만 보면 <strong>30배</strong>, watch mode는 sub-100ms 재시작.</p><h3>실전: 내 프로젝트는 괜찮을까?</h3><p>이론은 됐고, 실제 운영 중인 프로젝트의 tsconfig.json으로 검증해봤다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cgseltm7rb1QYApPErUouA.png" /></figure><pre>// 실제 운영 프로젝트 (TypeScript 5.x, Vite 기반)<br>{<br>  &quot;compilerOptions&quot;: {<br>    &quot;target&quot;: &quot;ES2020&quot;,<br>    &quot;module&quot;: &quot;ESNext&quot;,<br>    &quot;strict&quot;: true,<br>    &quot;esModuleInterop&quot;: true,<br>    &quot;rootDir&quot;: &quot;src&quot;,<br>    &quot;types&quot;: [&quot;node&quot;, &quot;vite/client&quot;]<br>  }<br>}</pre><p><strong>8개 항목 중 7개가 이미 호환.</strong> 평소에 모범 사례를 따르고 있었다면, 6.0은 거의 무통 업그레이드다.</p><p>반대로 strict 없이, CommonJS + ES5로 운영하고 있었다면 — 꽤 큰 작업이 필요하다.</p><h3>지금 해야 할 것</h3><pre># 1. 업그레이드<br>npm install typescript@6.0 --save-dev<br><br># 2. 자동 마이그레이션 (baseUrl, rootDir 처리)<br>npx ts5to6<br># 3. 7.0 미리 테스트 - 95% 코드는 그대로 통과<br>npx tsgo</pre><p><strong>6.0은 숙제고, 7.0은 보상이다.</strong></p><p>미루면 미룰수록, 나중에 한꺼번에 감당해야 할 breaking change가 쌓인다. 이미 strict를 켜고 있었다면 — 축하한다. 거의 끝났다.</p><p><strong>당신의 프로젝트는 </strong><strong>strict: true를 이미 켜고 있나요? 가장 걱정되는 변경사항은 뭔가요? 댓글로 알려주세요.</strong></p><p><em>References:</em><br> <a href="https://devblogs.microsoft.com/typescript/announcing-typescript-6-0/"><em>Announcing TypeScript 6.0</em></a><em> · </em><a href="https://gist.github.com/privatenumber/3d2e80da28f84ee30b77d53e1693378f"><em>5.x to 6.0 Migration Guide</em></a><em> · </em><a href="https://devblogs.microsoft.com/typescript/typescript-native-port/"><em>A 10x Faster TypeScript</em></a><em> · </em><a href="https://www.pkgpulse.com/blog/tsgo-vs-tsc-typescript-7-go-compiler-2026"><em>tsgo Benchmarks</em></a><em> · </em><a href="https://github.com/andrewbranch/ts5to6"><em>ts5to6 Tool</em></a><em> · </em><a href="https://www.totaltypescript.com/typescript-announces-go-rewrite"><em>Why Go — Total TypeScript</em></a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9c52e5b4f283" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Next.js만 쓰다가 TanStack Start 써봤습니다 — 데이터 시각화 개발자의 비교 후기]]></title>
            <link>https://eheh34w.medium.com/next-js%EB%A7%8C-%EC%93%B0%EB%8B%A4%EA%B0%80-tanstack-start-%EC%8D%A8%EB%B4%A4%EC%8A%B5%EB%8B%88%EB%8B%A4-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%8B%9C%EA%B0%81%ED%99%94-%EA%B0%9C%EB%B0%9C%EC%9E%90%EC%9D%98-%EB%B9%84%EA%B5%90-%ED%9B%84%EA%B8%B0-57d1fa466592?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/57d1fa466592</guid>
            <category><![CDATA[javscript]]></category>
            <category><![CDATA[nextjs]]></category>
            <category><![CDATA[tanstack]]></category>
            <category><![CDATA[reactjs]]></category>
            <category><![CDATA[web-development]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Fri, 20 Mar 2026 03:04:00 GMT</pubDate>
            <atom:updated>2026-03-20T03:04:00.051Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*omXTEvXkRDVcEl7EpOtykQ.png" /><figcaption>Next.js VS TanStack Start</figcaption></figure><p>2025년, React 풀스택 프레임워크 선택지가 하나 더 생겼다. Next.js의 Server Components가 답이 아닌 프로젝트를 위해.</p><p>React 18, D3, WebGL, 그리고 gRPC. 지난 몇 년간 대용량 데이터를 히트맵으로 시각화하는 프로젝트를 하면서 내가 믿고 써온 스택이다. 수십만 개의 데이터 포인트를 브라우저에서 실시간으로 렌더링해야 하는 상황에서, 이 조합은 꽤 잘 동작했다. React가 UI 상태를 잡아주고, D3가 스케일과 축을 계산하고, WebGL이 캔버스 위에서 무거운 렌더링을 처리하고, gRPC가 서버에서 대량의 바이너리 데이터를 빠르게 스트리밍해줬다.</p><p>그러다 새 프로젝트를 시작하게 됐다. 이번에도 대용량 데이터 시각화인데, 이왕이면 SSR도 적용하고, 라우팅도 좀 제대로 잡고, 풀스택으로 깔끔하게 가져가고 싶었다. 자연스럽게 Next.js를 떠올렸다. 2025년 기준으로 React 풀스택 프레임워크의 사실상 표준이니까.</p><p>그런데 막상 세팅을 시작하니 피로감이 먼저 왔다.</p><p>App Router로 전환하면서 바뀐 것들이 많았다. 서버 컴포넌트와 클라이언트 컴포넌트의 경계를 매번 &quot;use client&quot;로 선언해야 하고, D3나 WebGL처럼 DOM에 직접 접근하는 라이브러리를 쓸 때마다 hydration mismatch 경고를 만났다.</p><p>next.config.js에서 webpack 설정을 오버라이드하는 것도 일이었다. 내 프로젝트는 대부분의 무거운 렌더링을 클라이언트에서 WebGL로 처리하는데, Next.js는 서버 사이드 렌더링을 기본 전제로 깔고 있으니 매번 &quot;이건 서버에서 돌면 안 되는 코드&quot;라고 프레임워크를 설득해야 했다.</p><p>gRPC 클라이언트를 붙이는 것도 간단하지 않았다. Next.js의 API Route는 기본적으로 REST/HTTP 기반이라 gRPC-Web 프록시를 따로 구성하거나, 커스텀 서버를 띄워야 했다. Turbopack은 아직 protobuf 관련 로더 지원이 불안정했고, .proto 파일에서 생성된 타입을 제대로 해석하려면 webpack 설정으로 폴백해야 했다.</p><p>솔직히 말하면, Next.js 자체가 나쁜 프레임워크라는 게 아니다. 오히려 대부분의 웹 앱에는 훌륭한 선택이다. 하지만 내 유스케이스 — 클라이언트 헤비 렌더링 + 바이너리 데이터 스트리밍 + 최소한의 SSR — 에서는 Next.js가 제공하는 것의 절반은 쓸 일이 없고, 나머지 절반은 내 스택과 충돌하고 있었다. 프레임워크에 맞추려고 내 아키텍처를 바꾸는 건, 꼬리가 몸통을 흔드는 느낌이었다.</p><p>그때 Next.js의 대안을 찾다가 TanStack Start를 알게 됐다.</p><p>TanStack Query는 이미 잘 쓰고 있었고, TanStack Router가 타입 안전한 라우팅을 제공한다는 건 들어봤었다. 그런데 그 위에 풀스택 프레임워크가 올라왔다? Vite 기반이라 빌드가 빠르고, 서버 함수(Server Functions)로 백엔드 로직을 처리하면서도 클라이언트 코드에 대한 간섭이 최소한이라고 했다. 무엇보다 “라우터가 프레임워크의 중심”이라는 설계 철학이 끌렸다. 내가 원하는 건 거대한 프레임워크가 아니라, 라우팅과 데이터 페칭을 타입 안전하게 잡아주면서 나머지는 내가 자유롭게 구성할 수 있는 환경이었으니까.</p><p>그래서 직접 써봤다. 이 글은 그 과정에서 느낀 것들을 정리한 기록이다.</p><h3>TanStack Start란? — React Query 만든 사람의 풀스택 프레임워크</h3><p>TanStack이라는 이름이 낯선 사람은 드물 것이다. react-query로 시작해서 지금은 TanStack Query로 불리는 서버 상태 관리 라이브러리. React 개발자라면 한 번쯤은 써봤거나, 최소한 들어봤을 거다. 만든 사람은 Tanner Linsley.</p><p>Tanner는 Query에서 멈추지 않았다. TanStack Table, TanStack Form, 그리고 결정적으로 TanStack Router를 만들었다. 특히 Router는 기존 React Router와는 접근이 달랐다. 파일 기반 라우팅을 지원하면서도, 모든 라우트 경로와 파라미터가 TypeScript로 완전히 타입 추론되는 구조. useParams()를 호출하면 해당 라우트에서 쓸 수 있는 파라미터가 자동완성으로 뜨는 경험은, 한번 맛보면 돌아가기 어렵다.</p><p>TanStack Start는 이 Router 위에 풀스택 레이어를 얹은 것이다. 내부적으로는 Nitro(Nuxt의 서버 엔진) 기반의 Vinxi 위에서 돌아가고, Vite를 번들러로 사용한다. 2025년 말 기준으로 v1 Release Candidate가 나왔고, API는 안정 단계에 접어들었다.</p><p>핵심 설계 철학을 한 줄로 요약하면 이렇다: <strong>클라이언트 퍼스트, 서버는 옵트인.</strong></p><p>기본적으로 SPA처럼 동작하되, SSR이나 SSG가 필요하면 점진적으로 추가할 수 있다. Next.js가 “기본은 서버, 클라이언트는 선언하라”라면, TanStack Start는 “기본은 클라이언트, 서버가 필요하면 가져다 써라”다. 이 방향성의 차이가 내 프로젝트에서는 결정적이었다.</p><h3>Next.js vs TanStack Start — 2025년 React 프레임워크 비교</h3><p>둘 다 React 풀스택 프레임워크를 표방하지만, 써보면 체감이 꽤 다르다. 단순 스펙 나열보다는 실제로 개발하면서 느낀 차이 위주로 정리한다.</p><figure><img alt="비교 테이블" src="https://cdn-images-1.medium.com/max/1024/1*UlcfBN_NmlckSTnkSUhvuw.png" /><figcaption>비교 테이블</figcaption></figure><h3>Next.js App Router vs TanStack Router — type-safe routing 비교</h3><p>Next.js의 App Router는 폴더 구조가 곧 라우트다. app/dashboard/[id]/page.tsx를 만들면 /dashboard/123이 라우트가 된다. 직관적이지만, 문제는 타입이다. params.id가 string인 건 알겠는데, 이 라우트에 어떤 searchParams가 올 수 있는지, 다른 라우트로 이동할 때 경로가 유효한지는 런타임에서야 알 수 있다.</p><p>TanStack Router는 다르다. 라우트를 정의하면 경로, 파라미터, 검색 쿼리까지 전부 타입으로 추론된다.</p><pre>// TanStack Router: 라우트 정의<br>const dashboardRoute = createFileRoute(&#39;/dashboard/$id&#39;)({<br>  validateSearch: z.object({<br>    tab: z.enum([&#39;overview&#39;, &#39;detail&#39;, &#39;settings&#39;]).optional(),<br>  }),<br>  loader: ({ params }) =&gt; fetchDashboard(params.id),<br>  // params.id는 자동으로 string 타입<br>})</pre><p>&lt;Link to=&quot;/dashboard/$id&quot; params={{ id: &#39;123&#39; }} search={{ tab: &#39;overview&#39; }} /&gt;라고 쓰면, to에 존재하지 않는 라우트를 넣거나 params에 오타를 내면 컴파일 타임에 에러가 난다. 대규모 프로젝트에서 라우트가 수십 개로 늘어나면 이 차이가 체감된다.</p><h3>데이터 페칭 — Server Components vs Loader + Server Functions</h3><p>Next.js App Router에서 데이터를 가져오는 공식적인 방법은 Server Components 안에서 async/await로 직접 fetch하는 것이다. 간결하지만, 클라이언트 컴포넌트에서 데이터가 필요할 때는 다시 Server Action을 호출하거나, 별도의 API Route를 만들어야 한다. 서버와 클라이언트 사이의 경계가 코드 안에서 자주 왔다갔다한다.</p><p>TanStack Start는 라우트 레벨의 loader에서 데이터를 가져오고, 그걸 컴포넌트에서 가져다 쓰는 구조다. TanStack Query와 자연스럽게 통합되어 캐싱, 리밸리데이션, 옵티미스틱 업데이트가 익숙한 패턴 그대로 동작한다.</p><pre>// TanStack Start: loader에서 데이터 가져오기<br>export const Route = createFileRoute(&#39;/heatmap/$sensorId&#39;)({<br>  loader: async ({ params }) =&gt; {<br>    const data = await fetchSensorData(params.sensorId)<br>    return { data }<br>  },<br>  component: HeatmapView,<br>})</pre><pre>function HeatmapView() {<br>  const { data } = Route.useLoaderData()<br>  // 여기서 바로 WebGL로 렌더링<br>  return &lt;WebGLHeatmap data={data} /&gt;<br>}</pre><p>이미 TanStack Query를 쓰고 있었다면, 이 패턴에 적응하는 데 하루도 안 걸린다. 서버 함수(Server Functions)는 &quot;use server&quot; 디렉티브로 선언하는데, Next.js의 Server Actions과 비슷하지만 RPC 스타일로 동작해서 좀 더 명시적이다.</p><h3>Turbopack vs Vite — 번들러 DX 비교</h3><p>Next.js는 오랫동안 Webpack을 써왔고, 지금은 Turbopack으로 전환 중이다. Turbopack이 빠른 건 맞지만, 아직 Webpack 플러그인과의 호환성 문제가 있다. 특히 내 경우 protobuf 로더, WASM 관련 설정에서 Turbopack이 지원하지 않는 부분이 있어서 webpack으로 폴백해야 했다.</p><p>TanStack Start는 Vite 기반이다. 개발 서버 시작이 빠르고, HMR이 거의 즉각적이다. 그리고 Vite 플러그인 생태계를 그대로 쓸 수 있다는 게 크다. WASM 로딩, protobuf 컴파일, WebGL 셰이더 파일 임포트 등 내 프로젝트에서 필요한 것들이 Vite 플러그인으로 깔끔하게 해결됐다.</p><h3>WebGL, D3, Canvas — 클라이언트 헤비 코드에서의 차이</h3><p>이 부분이 내 프로젝트에서 가장 체감이 컸다. Next.js에서 D3를 쓰려면 &quot;use client&quot; 선언은 기본이고, dynamic(() =&gt; import(&#39;./HeatmapChart&#39;), { ssr: false })로 서버 렌더링을 꺼야 한다. WebGL context 생성, Canvas API 접근 — 전부 서버에서는 돌 수 없으니까. 프레임워크가 &quot;기본적으로 서버에서 실행한다&quot;는 전제를 깔고 있어서, 클라이언트 전용 코드가 많을수록 예외 처리가 쌓인다.</p><p>TanStack Start는 기본이 클라이언트다. SSR을 안 쓰겠다고 선언하면 그냥 SPA로 동작한다. SSR을 쓰더라도, 서버에서 실행되는 코드는 loader와 serverFn 안으로 명확하게 격리된다. 나머지 컴포넌트는 그냥 클라이언트에서 돌아간다. &quot;use client&quot; 같은 디렉티브를 매번 붙일 필요가 없다.</p><h3>배포 환경 — Vercel 종속 vs 멀티 런타임</h3><p>Next.js는 Vercel에 배포하면 매끄럽다. 하지만 다른 환경에 배포할 때는 조금 신경 쓸 것들이 있다. 특히 Standalone 모드 설정, Edge Runtime 호환성 같은 부분.</p><p>TanStack Start는 Nitro 기반이라 Node.js, Deno, Bun, Cloudflare Workers, Vercel 등 다양한 런타임에 배포할 수 있다. 서버 프리셋을 바꾸는 것만으로 타겟을 전환할 수 있어서 인프라 자유도가 높다.</p><h3>TanStack Start 장단점 — 솔직 정리</h3><h3>TanStack Start가 좋았던 점</h3><p><strong>타입 안전성이 압도적이다.</strong> 라우트 경로, 파라미터, 검색 쿼리, 로더 데이터까지 전부 타입으로 연결된다. IDE에서 자동완성이 제대로 동작하는 프레임워크를 처음 만난 느낌이었다. 리팩토링할 때 라우트 경로를 바꾸면 관련된 모든 &lt;Link&gt;에서 컴파일 에러가 난다. 이게 대규모 프로젝트에서는 굉장한 안전망이 된다.</p><p><strong>Vite 기반 DX가 쾌적하다.</strong> 콜드 스타트가 빠르고, HMR이 거의 즉각적이다. Next.js의 dev 서버가 프로젝트 규모가 커지면 느려지는 걸 경험한 사람이라면 체감이 클 것이다. 그리고 Vite 플러그인을 그대로 쓸 수 있어서 커스텀 빌드 설정이 훨씬 수월하다.</p><p><strong>클라이언트 코드에 간섭하지 않는다.</strong> 서버/클라이언트 경계가 명확하고, 클라이언트 전용 코드를 쓸 때 프레임워크와 싸울 일이 없다. D3, WebGL, Canvas API를 쓰는 내 유스케이스에서는 이게 결정적이었다.</p><p><strong>TanStack 생태계와의 통합.</strong> Query, Router, Form이 하나의 일관된 설계 철학 아래 동작한다. 다른 라이브러리를 조합할 때 느끼는 어색함이 없다.</p><h3>아쉬웠던 점</h3><p><strong>커뮤니티와 레퍼런스가 아직 적다.</strong> Next.js는 Stack Overflow, 블로그 글, 강의가 넘친다. TanStack Start는 공식 문서와 Discord가 사실상 유일한 정보원이다. 막혔을 때 구글링해서 답을 찾기가 어려웠다. 특히 엣지 케이스에서 삽질하는 시간이 좀 있었다.</p><p><strong>아직 RC(Release Candidate) 단계다.</strong> v1 RC까지 나왔고 API는 안정적이라고 하지만, 프로덕션에 바로 넣기엔 심리적 허들이 있다. 물론 TanStack Query도 처음엔 다 그랬으니, 시간 문제일 수 있다.</p><p><strong>미들웨어, 인증 등 풀스택 편의 기능이 덜 갖춰져 있다.</strong> Next.js의 middleware.ts, NextAuth 같은 잘 정돈된 솔루션에 비하면 TanStack Start에서는 직접 조합해야 할 것들이 많다. 자유도가 높다는 건 직접 해야 할 것도 많다는 뜻이다.</p><p><strong>서드파티 통합 가이드가 부족하다.</strong> Prisma, Drizzle, Auth.js 등과의 통합은 가능하지만, 공식 가이드가 잘 정리되어 있지 않다. Next.js처럼 “이 스택으로 시작하세요” 같은 레시피가 없어서 초기 세팅에 시간이 더 걸린다.</p><h3>TanStack Start 실제 사용 후기 — data visualization 프로젝트</h3><h3>프로젝트 세팅</h3><p>TanStack Start 프로젝트 초기 세팅은 깔끔했다. npm create @tanstack/start으로 시작하면 기본 구조가 잡히는데, Next.js의 create-next-app과 비교하면 생성되는 파일 수가 확연히 적다. 구조가 단순해서 &quot;이 파일은 왜 있지?&quot; 싶은 게 거의 없었다.</p><pre>my-app/<br>├── app/<br>│   ├── routes/<br>│   │   ├── __root.tsx<br>│   │   ├── index.tsx<br>│   │   └── heatmap.$sensorId.tsx<br>│   ├── client.tsx<br>│   ├── router.tsx<br>│   └── ssr.tsx<br>├── app.config.ts<br>└── package.json</pre><p>app.config.ts 하나로 서버 프리셋, Vite 플러그인, SSR 옵션을 제어한다. next.config.js에서 Webpack 설정을 오버라이드하던 기억과 비교하면, 설정 파일이 훨씬 읽기 쉬웠다.</p><h3>WebGL + D3 통합</h3><p>이 부분에서 가장 큰 차이를 느꼈다. Next.js에서는 이런 식으로 써야 했다:</p><pre>// Next.js: WebGL 컴포넌트를 동적 임포트<br>const HeatmapCanvas = dynamic(<br>  () =&gt; import(&#39;@/components/HeatmapCanvas&#39;),<br>  { ssr: false, loading: () =&gt; &lt;Skeleton /&gt; }<br>)</pre><p>TanStack Start에서는 그냥 쓰면 된다:</p><pre>// TanStack Start: 그냥 임포트<br>import { HeatmapCanvas } from &#39;@/components/HeatmapCanvas&#39;<br><br>function HeatmapView() {<br>  const { data } = Route.useLoaderData()<br>  return &lt;HeatmapCanvas data={data} /&gt;<br></pre><p>ssr: false도 없고, dynamic import도 없다. 컴포넌트가 클라이언트에서 돌아가는 게 기본이니까, DOM API를 쓰든 Canvas를 만들든 WebGL context를 초기화하든 그냥 하면 된다. 이 단순함이 개발 속도에 직결됐다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Fysw1VwSSXwn2TnfKSL6uw.png" /><figcaption>grpc 아키텍처</figcaption></figure><h3>gRPC 연동</h3><p>Vite 생태계 덕을 봤다. vite-plugin-proto로 .proto 파일을 빌드 타임에 처리하고, 생성된 TypeScript 타입을 서버 함수에서 바로 사용할 수 있었다. Next.js에서 겪었던 번들러 호환성 문제가 없었다.</p><pre>// 서버 함수에서 gRPC 호출<br>const fetchSensorData = createServerFn({ method: &#39;GET&#39; })<br>  .validator(z.object({ sensorId: z.string() }))<br>  .handler(async ({ data }) =&gt; {<br>    const client = createGrpcClient()<br>    const response = await client.getSensorData({<br>      id: data.sensorId,<br>    })<br>    return response.dataPoints<br>  })</pre><p>서버 함수 안에서 gRPC 클라이언트를 직접 호출할 수 있으니, gRPC-Web 프록시 같은 중간 레이어가 필요 없었다. 서버에서 네이티브 gRPC로 통신하고, 클라이언트에는 이미 파싱된 JSON 데이터만 내려주면 된다.</p><h3>개발 서버 속도</h3><p>체감상 확실히 빨랐다. 콜드 스타트가 1~2초 내외, HMR은 거의 즉각적. Next.js dev 서버가 프로젝트가 커지면서 점점 느려졌던 경험과 비교하면 쾌적했다. 물론 이건 Turbopack이 완성되면 격차가 줄어들 수 있다.</p><h3>결론: Next.js vs TanStack Start, 어떤 프로젝트에 어떤 프레임워크?</h3><p>“그래서 Next.js 버리나요?” 이 글을 읽은 사람이 가장 궁금해할 질문일 것이다. 답은 아니다.</p><p><strong>Next.js가 여전히 좋은 경우:</strong> 콘텐츠 중심 웹사이트, SEO가 중요한 마케팅 페이지, 이커머스, 풀스택 CRUD 앱 같이 서버 렌더링이 핵심인 프로젝트. Vercel 배포를 쓴다면 DX도 훌륭하고, 커뮤니티와 생태계는 비교 불가다. 팀에 주니어 개발자가 많다면 학습 자료가 풍부한 Next.js가 현실적인 선택이다.</p><p><strong>TanStack Start가 빛나는 경우:</strong> 클라이언트 사이드 렌더링이 중심인 앱, 데이터 시각화/대시보드/에디터 같은 인터랙티브 SPA, 타입 안전성을 극한까지 원하는 TypeScript 프로젝트, Vite 생태계를 적극 활용하고 싶은 경우, 그리고 프레임워크에 종속되지 않는 유연한 아키텍처를 원하는 경우.</p><p>결국은 “내 프로젝트가 서버 퍼스트인가, 클라이언트 퍼스트인가”에 대한 답이 곧 프레임워크 선택의 답이 된다.</p><p>나는 수십만 개의 데이터 포인트를 WebGL로 실시간 렌더링하고, gRPC로 바이너리 스트리밍을 처리하는 프로젝트를 하고 있다. 이 유스케이스에서 TanStack Start는 프레임워크가 방해하지 않는 프레임워크였다. 그리고 그게 내가 원하던 전부였다.</p><p>TanStack Start가 아직 초기 단계인 건 사실이다. 하지만 TanStack Query가 처음 나왔을 때도 다들 “react-query? 그거 안정적이야?”라고 했다. 지금은 어떤가. 프레임워크의 성숙도는 시간이 해결해주지만, 설계 철학은 처음부터 방향이 맞아야 한다. TanStack Start의 방향은 나와 맞았다.</p><p>이 글이 Next.js와 TanStack Start 사이에서 고민하는 누군가에게 판단의 근거가 되길 바란다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=57d1fa466592" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[50,000개 데이터가 3fps로 죽었을 때, WebGPU가 답이었다]]></title>
            <link>https://eheh34w.medium.com/50-000%EA%B0%9C-%EB%8D%B0%EC%9D%B4%ED%84%B0%EA%B0%80-3fps%EB%A1%9C-%EC%A3%BD%EC%97%88%EC%9D%84-%EB%95%8C-webgpu%EA%B0%80-%EB%8B%B5%EC%9D%B4%EC%97%88%EB%8B%A4-ff3dfd602aac?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/ff3dfd602aac</guid>
            <category><![CDATA[webgpu]]></category>
            <category><![CDATA[typescript]]></category>
            <category><![CDATA[graphics]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[data-visualization]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Thu, 05 Feb 2026 01:05:36 GMT</pubDate>
            <atom:updated>2026-02-05T01:05:36.197Z</atom:updated>
            <content:encoded><![CDATA[<h4>Canvas가 버벅거릴 때: WebGL에서 WebGPU로 마이그레이션한 이야기</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/893/1*w2KgzDok2fuRiND5YYhnDg.png" /></figure><h3>WebGPU 완전 정복: 왜 등장했고, 어떻게 쓰는가</h3><blockquote>“WebGL로 충분하지 않나요?” — 저도 그렇게 생각했습니다. 50,000개 데이터를 실시간으로 그리기 전까지는.</blockquote><h3>1. 들어가며: 왜 WebGPU인가</h3><h3>문제의 시작</h3><p>설비 및 장비 검사 시스템을 개발하던 중이었습니다. 요구사항은 단순했습니다.</p><blockquote>“튜브 50,000개를 3D로 시각화하고, 실시간으로 색상이 바뀌어야 합니다.”</blockquote><p>처음에는 자신 있었습니다. Three.js? Babylon.js? 어떤 라이브러리든 쉽게 해결할 수 있을 거라 생각했죠.</p><p>결과는 3fps. 화면이 슬라이드쇼처럼 버벅거렸습니다.</p><p>“왜?”라는 질문에서 시작된 여정이, 저를 GPU 프로그래밍의 세계로 이끌었습니다. 그리고 마침내 WebGPU를 만났습니다.</p><h3>2. 그래픽 API의 역사</h3><p>WebGPU를 이해하려면, 먼저 그래픽 API가 어떻게 발전해왔는지 알아야 합니다.</p><h3>데스크톱 시대 (1990~2010)</h3><ul><li>1992년 — OpenGL 1.0: 3D 그래픽의 표준이 탄생</li><li>1995년 — Direct3D: Windows 게임의 왕이 등장</li><li>2006년 — OpenGL 3.0: 현대화를 시도했지만, 레거시를 유지</li></ul><p>이 시대의 특징: OpenGL은 크로스 플랫폼, Direct3D는 Windows 전용이지만 게임에 최적화. 둘 다 “상태 기계(State Machine)” 패러다임을 사용했습니다.</p><h3>모바일 시대 (2007~2017)</h3><p>스마트폰이 등장하면서 새로운 도전이 시작됩니다.</p><ul><li>2007년 — OpenGL ES 2.0: 모바일용 경량 OpenGL</li><li>2011년 — WebGL 1.0: 🌐 브라우저에서 3D가 가능해짐!</li><li>2017년 — WebGL 2.0: OpenGL ES 3.0 기반</li></ul><p>WebGL의 등장은 혁명이었습니다. 플러그인 없이 브라우저에서 3D 그래픽이 가능해졌으니까요.</p><h3>현대 시대 (2013~현재)</h3><p>하지만 하드웨어는 빠르게 발전하는데, API는 따라가지 못했습니다.</p><ul><li>2013년 — AMD Mantle: 저수준 API의 시작</li><li>2014년 — Apple Metal: iOS/Mac 전용, 저수준</li><li>2015년 — Direct3D 12: Windows의 저수준 API</li><li>2016년 — Vulkan: OpenGL의 후계자, 크로스 플랫폼</li><li>2023년 — WebGPU 1.0: 🚀 웹의 새로운 시대!</li></ul><h3>왜 “저수준(Low-Level)” API가 필요했나?</h3><p>기존 OpenGL/WebGL의 문제:</p><ol><li>드라이버가 너무 많은 일을 함 — 개발자가 의도하지 않은 최적화, 예측 불가능한 성능</li><li>상태 기계 패러다임의 한계 — 전역 상태 변경으로 버그 발생 쉬움, 멀티스레딩 불가능</li><li>CPU 병목 현상 — Draw Call마다 CPU 오버헤드, GPU는 놀고 CPU만 바쁨</li></ol><h3>3. WebGL의 한계</h3><h3>상태 기계(State Machine)란?</h3><p>WebGL은 전역 상태를 변경하며 동작합니다.</p><pre>// WebGL의 상태 기계 방식<br>gl.bindBuffer(gl.ARRAY_BUFFER, buffer1);    // 상태 변경<br>gl.bindTexture(gl.TEXTURE_2D, texture1);    // 상태 변경<br>gl.useProgram(program1);                     // 상태 변경<br>gl.drawArrays(gl.TRIANGLES, 0, 100);        // 현재 상태로 그려!<br>// 다른 객체를 그리려면 상태를 다시 변경<br>gl.bindBuffer(gl.ARRAY_BUFFER, buffer2);    // 상태 변경<br>gl.drawArrays(gl.TRIANGLES, 0, 200);        // 그려!</pre><p>문제점:</p><ul><li>현재 상태가 뭔지 추적하기 어려움</li><li>상태 변경을 깜빡하면 버그 발생</li><li>다른 코드가 상태를 바꿔버릴 수 있음</li></ul><h3>CPU 병목 현상</h3><p>WebGL에서 50,000개 객체를 그린다면:</p><pre>CPU                                    GPU<br> │                                      │<br> ├── gl.bindBuffer() ─────────────────→ │<br> ├── gl.drawArrays() ─────────────────→ │ (그림)<br> │                                      │<br> ├── gl.bindBuffer() ─────────────────→ │<br> ├── gl.drawArrays() ─────────────────→ │ (그림)<br> │                                      │<br> │   ... 50,000번 반복 ...               │<br> │                                      │<br> └── 😰 CPU가 병목!                     │ 💤 GPU는 대기</pre><p>각 Draw Call마다 JavaScript → WebGL → 드라이버 → GPU 통신 오버헤드가 발생합니다.</p><h3>Compute Shader 부재</h3><p>WebGL에는 Compute Shader가 없습니다.</p><p>Compute Shader란? 렌더링 없이 순수 계산만 GPU에서 수행하는 것. 물리 시뮬레이션, 데이터 처리에 필수입니다.</p><pre>// WebGL에서 GPU 계산을 하려면?<br>// → 꼼수: 텍스처에 데이터를 담고, 렌더링하면서 계산 😅<br>const inputTexture = createTextureFromData(data);<br>gl.drawArrays(gl.TRIANGLES, 0, 6);  // 화면에 그리는 척 하면서 계산<br>gl.readPixels(...);  // 결과를 텍스처에서 읽기</pre><p>계산을 하려고 삼각형을 그리는 겁니다. 말이 됩니까?</p><h3>4. WebGPU의 등장</h3><h3>WebGPU란?</h3><p>WebGPU는 W3C에서 표준화한 차세대 웹 그래픽 API입니다.</p><p>설계 철학: “Vulkan, Metal, Direct3D 12의 장점을 웹으로 가져오자”</p><h3>WebGPU의 핵심 특징</h3><h4>1) 명령 기반 (Command-based) API</h4><pre>// WebGPU 방식: 명령을 기록하고, 한 번에 제출<br>const commandEncoder = device.createCommandEncoder();<br>// 명령 기록 (아직 실행 안 함!)<br>const passEncoder = commandEncoder.beginRenderPass(descriptor);<br>passEncoder.setPipeline(pipeline);<br>passEncoder.setVertexBuffer(0, vertexBuffer);<br>passEncoder.draw(vertexCount);<br>passEncoder.end();<br>// 명령 제출 (이제 GPU가 실행)<br>device.queue.submit([commandEncoder.finish()]);</pre><p>장점: 명령을 미리 기록해서 재사용 가능, 드라이버 오버헤드 감소, 예측 가능한 성능</p><h4>2) Compute Shader 지원</h4><pre>// WGSL (WebGPU Shading Language)<br>@compute @workgroup_size(256)<br>fn main(@builtin(global_invocation_id) id: vec3&lt;u32&gt;) {<br>    let index = id.x;<br>// 순수 계산 - 렌더링 없이!<br>    output[index] = input[index] * 2.0;<br>}</pre><p>드디어 정당하게 GPU에서 계산할 수 있습니다!</p><h4>3) 명시적 메모리 관리</h4><pre>// 버퍼 생성 시 용도를 명확히 지정<br>const vertexBuffer = device.createBuffer({<br>  size: data.byteLength,<br>  usage: GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_DST,<br>});</pre><h4>4) Pipeline State Object (PSO)</h4><p>모든 렌더링 상태를 하나의 객체로 묶어서, 파이프라인 생성 시 검증이 완료됩니다. 런타임 오버헤드가 없어집니다.</p><h3>5. WebGPU vs WebGL: 핵심 차이</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/752/1*RhmibvCiSQu7gtvynlVLTQ.png" /></figure><h3>성능 비교 (50,000개 점 렌더링)</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/751/1*KA1EydVeinLvdEQKZt-LBQ.png" /></figure><h3>6. WebGPU 시작하기</h3><h3>브라우저 지원 확인</h3><pre>async function checkWebGPUSupport() {<br>  if (!navigator.gpu) {<br>    console.log(&#39;WebGPU를 지원하지 않는 브라우저입니다.&#39;);<br>    return null;<br>  }<br>const adapter = await navigator.gpu.requestAdapter();<br>  const device = await adapter.requestDevice();<br>  console.log(&#39;WebGPU 사용 가능!&#39;);<br>  return device;<br>}</pre><h3>Hello Triangle 예제</h3><pre>// 1. 초기화<br>const adapter = await navigator.gpu.requestAdapter();<br>const device = await adapter.requestDevice();<br>const context = canvas.getContext(&#39;webgpu&#39;);</pre><pre>// 2. 셰이더 (WGSL)<br>const shaderCode = `<br>  @vertex<br>  fn vertexMain(@location(0) pos: vec2f) -&gt; @builtin(position) vec4f {<br>    return vec4f(pos, 0.0, 1.0);<br>  }<br>  @fragment<br>  fn fragmentMain() -&gt; @location(0) vec4f {<br>    return vec4f(1.0, 0.5, 0.0, 1.0);  // 주황색<br>  }<br>`;<br>// 3. 파이프라인 생성<br>const pipeline = device.createRenderPipeline({<br>  layout: &#39;auto&#39;,<br>  vertex: { module: device.createShaderModule({ code: shaderCode }), entryPoint: &#39;vertexMain&#39; },<br>  fragment: { module: device.createShaderModule({ code: shaderCode }), entryPoint: &#39;fragmentMain&#39; },<br>});<br>// 4. 렌더링<br>function render() {<br>  const commandEncoder = device.createCommandEncoder();<br>  const pass = commandEncoder.beginRenderPass({ ... });<br>  pass.setPipeline(pipeline);<br>  pass.draw(3);<br>  pass.end();<br>  device.queue.submit([commandEncoder.finish()]);<br>}</pre><h3>7. 실전: 대용량 데이터 시각화</h3><h3>인스턴싱의 마법</h3><p>핵심은 인스턴싱(Instancing)입니다.</p><p>기본 모양 1개 + 50,000개 변환 정보 = 50,000개 렌더링 (1번의 Draw Call로!)</p><pre>// 핵심 코드<br>pass.draw(<br>  vertexCount,  // 정점 수<br>  50000         // 인스턴스 수 ← 여기가 핵심!<br>);</pre><h3>최종 결과</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/709/1*iTwmdK4Wy9DX--BxcHGDhw.png" /></figure><h3>8. 마치며</h3><h3>WebGPU를 써야 하는 경우</h3><p>✅ 강력 추천:</p><ul><li>데이터 10,000개 이상 시각화</li><li>실시간 업데이트 (1초 이내)</li><li>3D 렌더링</li><li>GPU 계산 (머신러닝, 물리 시뮬레이션)</li></ul><p>⚠️ 고려 필요:</p><ul><li>Safari 지원 필요 (아직 미지원)</li><li>간단한 정적 차트 (오버엔지니어링)</li></ul><h3>추천 라이브러리</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/723/1*X76r9ZXTRbJ7OpZgKc6j1w.png" /></figure><p><em>이 글은 </em>설비 및 장비<em> 시스템에서 50,000개 장치를 3D로 시각화하며 얻은 경험을 바탕으로 작성되었습니다.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ff3dfd602aac" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[NestJS + TypeORM으로 오프라인 UUID 데이터 서버에 안전하게 이관하는 방법]]></title>
            <link>https://eheh34w.medium.com/nestjs-typeorm%EC%9C%BC%EB%A1%9C-%EC%98%A4%ED%94%84%EB%9D%BC%EC%9D%B8-uuid-%EB%8D%B0%EC%9D%B4%ED%84%B0-%EC%84%9C%EB%B2%84%EC%97%90-%EC%95%88%EC%A0%84%ED%95%98%EA%B2%8C-%EC%9D%B4%EA%B4%80%ED%95%98%EB%8A%94-%EB%B0%A9%EB%B2%95-61aa68c4ccc1?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/61aa68c4ccc1</guid>
            <category><![CDATA[nestjs]]></category>
            <category><![CDATA[typeorm]]></category>
            <category><![CDATA[postgresql]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Sat, 19 Apr 2025 10:02:44 GMT</pubDate>
            <atom:updated>2025-04-19T10:02:44.475Z</atom:updated>
            <content:encoded><![CDATA[<blockquote><em>NestJS + TypeORM으로 오프라인 UUID 데이터 서버에 안전하게 이관하는 방법</em></blockquote><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WUzGMBHaRFsPXpuMQet7FA.png" /></figure><h3>NestJS + TypeORM으로 오프라인 UUID 데이터 서버에 안전하게 이관하는 방법</h3><h3>1. 도입</h3><p>웹 기반으로 운영되는 솔루션을 개발하던 중, 인터넷이 안 되는 환경에서도 동작해야 하는 요구사항이 생겼다. 처음엔 단순히 데이터를 로컬에 저장하는 수준이면 될 줄 알았는데, 알고 보니 여러 엔티티가 서로 얽혀 있고, 이후에는 이 데이터를 서버로 안전하게 옮겨야 했다.</p><p>이 글은 그 과정을 정리한 글이다. 어떤 방법들을 고민했고, 왜 어떤 건 안 쓰게 되었고, 어떤 방식이 최종적으로 잘 작동했는지를 내가 겪은 순서대로 풀어보려고 한다.</p><h3>2. 데이터 구조와 제약</h3><p>내가 다룬 데이터는 대략 15개 넘는 테이블이 서로 연결된 구조였다. 다행히 모든 테이블이 UUID 기반의 Primary Key를 사용하고 있어서 기본적으로는 충돌을 피할 수 있을 거라고 생각했지만, 막상 이관을 하려고 보니 생각보다 복잡했다.</p><p>예를 들어 구조는 이런 느낌:</p><pre>Organization<br>├── Project<br>│   └── Inspection<br>├── Facility<br>│   └── Inspection</pre><p>Inspection을 서버에 넣으려면 당연히 그 위에 있는 Project나 Facility가 먼저 서버에 있어야 한다. 순서가 안 맞으면 외래키 에러가 난다. 또, UUID가 중복될 일은 거의 없지만, 혹시라도 예전에 동일한 데이터가 서버에 올라간 적이 있다면 insert 자체가 실패할 수 있다.</p><h3>3. 이관 전략 설계</h3><h3>3.1 이런 방법들도 고려해봤다</h3><h4>SQL dump → restore</h4><p>pg_dump로 백업해서 서버에 복원하는 방법도 처음엔 생각했다. 근데 FK 순서 맞추는 게 너무 까다롭고, 중간에 하나라도 실패하면 전체가 꼬일 위험이 있어서 포기했다.</p><h4>API로 전송</h4><p>서버에 POST API 만들어서 하나씩 보내는 방식도 생각해봤다. 근데 이건 네트워크 연결이 없으면 안 되고, 데이터가 많아지면 timeout 나기 딱 좋고, 무엇보다 인증이 번거로워서 제외했다.</p><h3>3.2 그래서 결정한 방식</h3><p>결국 내가 선택한 방식은 TypeORM을 써서 로컬 DB와 서버 DB를 동시에 연결하고, 엔티티 단위로 데이터를 하나씩 확인하면서 서버로 옮기는 구조였다.</p><pre>const localDataSource = new DataSource({<br>  type: &#39;postgres&#39;,<br>  host: &#39;localhost&#39;,<br>  port: 5432,<br>  username: &#39;local_user&#39;,<br>  password: &#39;local_pass&#39;,<br>  database: &#39;local_db&#39;,<br>  entities: [Organization, Facility, Project, Inspection],<br>});</pre><pre>const serverDataSource = new DataSource({<br>  type: &#39;postgres&#39;,<br>  host: &#39;main-db-host&#39;,<br>  port: 5432,<br>  username: &#39;main_user&#39;,<br>  password: &#39;main_pass&#39;,<br>  database: &#39;main_db&#39;,<br>  entities: [Organization, Facility, Project, Inspection],<br>});</pre><h3>3.3 순서 중요!</h3><p>관계형 데이터는 부모 먼저, 자식 나중에 넣어야 FK 충돌이 안 난다. 그래서 이 순서로 이관했다:</p><pre>1. Organization<br>2. Facility<br>3. Project<br>4. Inspection</pre><h3>3.4 UUID 중복을 막기 위한 insert 전략</h3><p>처음엔 그냥 save()만 쓰면 되겠지 했는데, 이미 서버에 있는 UUID라면 에러가 난다. 그래서 아래처럼 존재 여부 확인 후 저장하는 방식으로 바꿨다.</p><pre>const exists = await serverRepo.findOneBy({ id: item.id });<br>if (!exists) {<br>  await serverRepo.save(item);<br>}</pre><h3>3.5 혹시 모를 실패에 대비해서</h3><ul><li>모든 insert는 try/catch로 감싸고,</li><li>실패한 건 console.error로 로그 남기고,</li><li>너무 많을 땐 take, skip으로 chunk 나눠서 처리했다.</li></ul><h3>4. 실제로 사용한 스크립트 예제</h3><pre>async function transferEntity&lt;T&gt;(entity: { new (): T }, name: string) {<br>  const localRepo = localDB.getRepository(entity);<br>  const serverRepo = serverDB.getRepository(entity);</pre><pre>  const localItems = await localRepo.find();<br>  console.log(`🟡 ${name}: ${localItems.length}개 전송 시도`);</pre><pre>  for (const item of localItems) {<br>    const exists = await serverRepo.findOneBy({ id: item[&#39;id&#39;] });<br>    if (!exists) {<br>      try {<br>        await serverRepo.save(item);<br>      } catch (error) {<br>        console.error(`[ERROR] ${name}: ${item[&#39;id&#39;]}`, error);<br>      }<br>    }<br>  }</pre><pre>  console.log(`✅ ${name} 완료`);<br>}</pre><h3>5. 시행착오와 내가 느낀 점</h3><p>처음엔 dump 방식도 써보고, API로도 전송해보고 했지만 오류도 많이 나고, 실패한 거 다시 넣는 것도 귀찮았다. 결국 지금 방식이 제일 깔끔했다.</p><ul><li>순서가 중요하다 (부모 먼저!)</li><li>UUID는 중복될 가능성이 낮지만 절대 없는 건 아니다</li><li>로깅과 재처리를 미리 생각해두면 나중에 편하다</li></ul><h3>6. 결과와 확장 가능성</h3><ul><li>수천 개 데이터도 수 초 만에 전송됨</li><li>UUID 중복이나 FK 오류 없이 성공</li><li>CLI 명령어로 만들면 운영에도 쉽게 붙일 수 있을 듯</li></ul><h3>7. 마무리하며</h3><p>개발을 하다 보면 예외적인 요구사항이 언제든 튀어나올 수 있다는 걸 이번 경험을 통해 새삼 느꼈다. TypeORM으로 로컬과 서버를 동시에 연결하고, 관계 순서를 지키며 안전하게 데이터를 이관하는 구조를 만든 경험은 꽤 재미있었다.</p><p>이 글이 비슷한 상황을 겪는 사람들에게 작은 참고가 될 수 있다면 좋겠다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=61aa68c4ccc1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[성장하는 React 프로젝트의 효율적 관리: Turborepo와 Vite로 모노레포 구성하기]]></title>
            <link>https://eheh34w.medium.com/%EC%84%B1%EC%9E%A5%ED%95%98%EB%8A%94-react-%ED%94%84%EB%A1%9C%EC%A0%9D%ED%8A%B8%EC%9D%98-%ED%9A%A8%EC%9C%A8%EC%A0%81-%EA%B4%80%EB%A6%AC-turborepo%EC%99%80-vite%EB%A1%9C-%EB%AA%A8%EB%85%B8%EB%A0%88%ED%8F%AC-%EA%B5%AC%EC%84%B1%ED%95%98%EA%B8%B0-da7b5ec026d8?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/da7b5ec026d8</guid>
            <category><![CDATA[모노레포]]></category>
            <category><![CDATA[front-end-development]]></category>
            <category><![CDATA[react]]></category>
            <category><![CDATA[monorepo]]></category>
            <category><![CDATA[tubo]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Fri, 23 Aug 2024 04:25:32 GMT</pubDate>
            <atom:updated>2024-08-23T04:25:32.817Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*17IA-3SNuqNqkvqg.png" /></figure><h3>배경 및 도입 이유</h3><p>우리 회사는 초기에는 하나의 제품에 집중하여 개발을 진행해왔습니다. 이 제품은 React를 기반으로 구축되었고, 작은 팀이 효율적으로 관리할 수 있을 정도의 규모였습니다. 하지만 시간이 지나면서 제품 라인업이 확장되기 시작했고, 이에 따라 여러 개의 애플리케이션과 라이브러리를 관리해야 하는 상황이 되었습니다.</p><p>이 시점에서 우리는 다음과 같은 문제들을 직면하게 되었습니다:</p><ol><li><strong>코드 중복 및 유지보수 부담</strong>: 각 제품이 개별적으로 개발되면서 비슷한 기능을 중복 구현하거나, 서로 다른 프로젝트에서 동일한 코드가 여러 번 복사되어 사용되는 경우가 많아졌습니다. 이는 코드의 일관성을 유지하기 어렵게 하고, 유지보수의 부담을 증가시켰습니다.</li><li><strong>의존성 관리의 복잡성</strong>: 각 프로젝트마다 서로 다른 의존성 버전을 사용하게 되면서, 이를 관리하고 일관되게 유지하는 데 많은 시간이 소요되었습니다. 특히, 공통으로 사용하는 UI 컴포넌트나 유틸리티 라이브러리의 경우, 업데이트를 각각의 프로젝트에 적용하는 것이 매우 비효율적이었습니다.</li><li><strong>프로젝트 간 협업의 비효율성</strong>: 팀이 여러 프로젝트에 걸쳐 작업을 하다 보니, 개발자 간 협업이 복잡해졌습니다. 예를 들어, 하나의 기능을 여러 제품에 걸쳐 구현해야 할 때, 각 프로젝트의 설정, 빌드 도구, 릴리즈 프로세스를 일일이 맞추는 데 많은 노력이 필요했습니다.</li></ol><h3>모노레포 도입 및 시작하기</h3><p>위와 같은 문제를 해결하기 위해, 우리는 <strong>모노레포(Monorepo)</strong> 전략을 도입하기로 결정했습니다. 모노레포는 여러 프로젝트를 하나의 리포지토리에서 관리할 수 있도록 하여 코드 재사용성을 높이고, 일관된 의존성 관리를 가능하게 하며, 팀 간 협업을 효율적으로 할 수 있도록 해줍니다.</p><p>모노레포 환경을 구축하기 위해 여러 도구를 검토한 끝에, 우리는 <strong>PNPM</strong>을 패키지 매니저로 선택했습니다. PNPM을 선택한 이유는 다음과 같습니다</p><ul><li><strong>효율적인 디스크 사용</strong>: PNPM은 중복된 패키지를 디스크에 여러 번 저장하지 않고, 심볼릭 링크를 활용하여 공간을 절약합니다. 이는 특히 모노레포 구조에서 여러 프로젝트가 동일한 패키지를 공유할 때 유용합니다.</li><li><strong>빠른 설치 속도</strong>: PNPM은 패키지 설치 속도가 빠르고, 네트워크 캐싱 및 병렬 다운로드를 통해 큰 규모의 프로젝트에서도 효율적으로 의존성을 관리할 수 있습니다.</li><li><strong>워크스페이스 지원</strong>: PNPM은 워크스페이스 기능을 기본적으로 지원하여, 여러 프로젝트 간의 의존성을 쉽게 관리할 수 있습니다. 이를 통해 패키지 간의 참조와 동기화를 간편하게 처리할 수 있으며, 프로젝트 전반에 걸쳐 일관된 버전 관리가 가능합니다.</li><li><strong>직관적인 설정 및 관리</strong>: PNPM은 설정이 간단하고, 기존 NPM 또는 Yarn 프로젝트에서 쉽게 마이그레이션할 수 있어, 개발자들이 익숙하게 사용할 수 있습니다.</li></ul><h4>1. 프로젝트 초기 설정</h4><p>우선, 모노레포 환경을 구성하기 위해 프로젝트를 초기화하고, 필요한 폴더 구조를 설정합니다. 여기서는 <strong>Turborepo</strong>와 <strong>PNPM</strong>을 활용하여 모노레포를 구성해보겠습니다.</p><pre>mkdir my-monorepo<br>cd my-monorepo<br>pnpm init</pre><p>pnpm-workspace.yaml 파일을 생성하고, 워크스페이스의 패키지를 지정합니다.</p><pre>packages:<br>  - &#39;apps/*&#39;<br>  - &#39;packages/*&#39;packages:</pre><p>이제 apps와 packages 폴더를 생성하여, 각각 애플리케이션과 공유 패키지를 관리할 수 있는 구조를 만듭니다.</p><pre>mkdir apps packages</pre><h4>2. React 애플리케이션 생성</h4><p>이제, Vite를 이용해 첫 번째 React 애플리케이션을 생성합니다.</p><pre>cd apps<br><br># my-app 생성<br>pnpm create vite@latest my-app --template react<br><br># web1 생성<br>pnpm create vite@latest web1 --template react<br><br># web2 생성<br>pnpm create vite@latest web2 --template react<br><br># 생성된 애플리케이션의 의존성 설치<br>cd my-app &amp;&amp; pnpm install<br>cd ../web1 &amp;&amp; pnpm install<br>cd ../web2 &amp;&amp; pnpm install<br><br># 프로젝트 루트로 돌아가기<br>cd ../..생성된 애플리케이션의 의존성을 설치합니다.</pre><pre>cd apps/my-app<br>pnpm install<br>cd ../..</pre><h4>3. Vite 설정 및 빌드 경로 설정</h4><p>각 애플리케이션이 특정 경로에서 서빙될 수 있도록 vite.config.ts 파일을 설정합니다.</p><p>예를 들어, web1 애플리케이션의 경우:</p><pre>import { defineConfig } from &#39;vite&#39;<br>import react from &#39;@vitejs/plugin-react&#39;<br><br>export default defineConfig({<br>  plugins: [react()],<br>  base: &#39;/web1/&#39;, // web1 애플리케이션이 /web1 경로에서 서빙되도록 설정<br>  build: {<br>    outDir: &#39;../../dist/web1&#39;, // 빌드된 파일이 저장될 경로<br>  },<br>})</pre><p>web2도 비슷하게 설정하고, my-app은 루트 경로에서 서빙되므로 base 경로를 설정하지 않습니다.</p><h4>4. Turborepo 설정</h4><p>모노레포의 빌드를 관리하기 위해 turbo.json 파일을 설정합니다.</p><pre>{<br>  &quot;pipeline&quot;: {<br>    &quot;build&quot;: {<br>      &quot;dependsOn&quot;: [&quot;^build&quot;],<br>      &quot;outputs&quot;: [&quot;dist/**&quot;]<br>    },<br>    &quot;dev&quot;: {<br>      &quot;cache&quot;: false,<br>      &quot;parallel&quot;: true,<br>      &quot;dependsOn&quot;: [&quot;^dev&quot;]<br>    }<br>  }<br>}</pre><p>이제 모든 애플리케이션을 빌드하기 위해 다음 명령어를 실행합니다.</p><pre>pnpm turbo run build</pre><h4>5. Express 설정을 통한 확인</h4><p>프로젝트 루트에 server.js 파일을 생성하고, 다음과 같이 내용을 작성합니다</p><pre>const express = require(&#39;express&#39;);<br>const path = require(&#39;path&#39;);<br><br>const app = express();<br><br>// my-app을 루트 경로에서 서빙<br>app.use(&#39;/&#39;, express.static(path.join(__dirname, &#39;dist/my-app&#39;)));<br>app.get(&#39;/*&#39;, (req, res) =&gt; {<br>  res.sendFile(path.join(__dirname, &#39;dist/my-app/index.html&#39;));<br>});<br><br>// web1을 /web1 경로에서 서빙<br>app.use(&#39;/web1&#39;, express.static(path.join(__dirname, &#39;dist/web1&#39;)));<br>app.get(&#39;/web1/*&#39;, (req, res) =&gt; {<br>  res.sendFile(path.join(__dirname, &#39;dist/web1/index.html&#39;));<br>});<br><br>// web2를 /web2 경로에서 서빙<br>app.use(&#39;/web2&#39;, express.static(path.join(__dirname, &#39;dist/web2&#39;)));<br>app.get(&#39;/web2/*&#39;, (req, res) =&gt; {<br>  res.sendFile(path.join(__dirname, &#39;dist/web2/index.html&#39;));<br>});<br><br>// 포트 설정<br>const PORT = process.env.PORT || 80;<br>app.listen(PORT, () =&gt; {<br>  console.log(`Server is running on port ${PORT}`);<br>});</pre><p>server.js를 실행하여 애플리케이션들을 서빙합니다. 다음 명령어를 사용하여 Node.js 서버를 실행합니다.</p><pre>node server.js</pre><p>이제 my-app은 루트 경로(/)에서, web1은 /web1, web2는 /web2 경로에서 서빙됩니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ghhWuxAcOkz_drX1q9SWAQ.png" /><figcaption>결과 화면</figcaption></figure><h3>모노레포를 통한 효율적인 프로젝트 관리</h3><p>이번 포스트에서는 React 프로젝트의 확장과 관리 효율성을 높이기 위해 Turborepo와 Vite를 활용한 모노레포 구조를 도입한 과정을 공유했습니다. 모노레포 도입은 단순히 여러 프로젝트를 하나의 리포지토리로 통합하는 것을 넘어, 코드 재사용성과 협업 효율성을 극대화하는 데 큰 도움이 되었습니다.</p><p>모노레포를 통해 우리는 다음과 같은 주요 이점을 누릴 수 있었습니다:</p><ul><li><strong>코드 재사용성</strong>: 공통된 코드베이스를 여러 프로젝트에서 쉽게 재사용함으로써, 중복 코드 작성과 유지보수의 부담을 크게 줄일 수 있었습니다.</li><li><strong>일관된 의존성 관리</strong>: 여러 프로젝트 간 의존성을 일관되게 관리함으로써, 업데이트와 유지보수가 용이해졌습니다.</li><li><strong>협업의 효율성 향상</strong>: 모든 프로젝트를 하나의 리포지토리에서 관리함으로써, 팀 간 협업이 원활해지고, 개발 속도와 생산성이 크게 향상되었습니다.</li></ul><p>앞으로도 우리는 프로젝트가 성장함에 따라, 모노레포 환경에서 더욱 효율적인 개발을 지원할 추가적인 도구와 전략들을 도입할 계획입니다. 예를 들어:</p><ul><li><strong>CI/CD 파이프라인 자동화</strong>: 테스트와 린팅을 자동화하여 코드 품질을 지속적으로 유지하고, 배포 과정을 간소화할 것입니다.</li><li><strong>캐싱 및 병렬 빌드</strong>: 프로젝트 규모가 커짐에 따라, 빌드 속도를 최적화하기 위해 캐싱과 병렬 빌드 전략을 강화할 계획입니다.</li></ul><p>모노레포는 단순한 기술적 선택을 넘어, 우리 팀의 개발 문화를 더 효율적이고 협력적으로 만드는 데 중요한 역할을 하고 있습니다. 이 글이 여러분의 프로젝트 관리에 도움이 되었기를 바라며, 앞으로도 모노레포 환경을 지속적으로 발전시켜 더 나은 소프트웨어를 개발해 나가길 기대합니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=da7b5ec026d8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[PostgreSQL vs MySQL]]></title>
            <link>https://eheh34w.medium.com/postgresql-vs-mysql-d8f1ac631b39?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/d8f1ac631b39</guid>
            <category><![CDATA[postgresql]]></category>
            <category><![CDATA[development]]></category>
            <category><![CDATA[mysql]]></category>
            <category><![CDATA[sql]]></category>
            <category><![CDATA[postgres]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Wed, 19 Jun 2024 01:55:31 GMT</pubDate>
            <atom:updated>2024-06-19T01:55:31.876Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/700/0*029qfqc7agYpNfwa" /></figure><h3>데이터베이스 선택의 중요성</h3><p>데이터베이스 선택의 중요성 데이터베이스 선택은 단순한 기술적 결정을 넘어서 프로젝트의 성공을 좌우할 수 있습니다.</p><p>예를 들어, 적절하지 않은 데이터베이스 선택은 성능 저하, 비효율적인 리소스 사용, 유지 관리 어려움을 초래하여 장기적으로 비용과 시간의 손실을 야기할 수 있습니다. MySQL과 PostgreSQL은 가장 널리 사용되는 관계형 데이터베이스 관리 시스템(RDBMS) 중 두 가지입니다.</p><p>이 글에서는 두 데이터베이스의 주요 차이점을 비교하고, 실제 사용 사례를 통해 어떤 데이터베이스를 선택해야 할지에 대한 가이드라인을 제공하려고 합니다.</p><p>이제 MySQL과 PostgreSQL의 기술적인 차이점부터 시작해 보겠습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/593/1*dN0JsVQjXfSlYdyqlgmMrg.png" /></figure><p>위 테이블 비교에서 말해주듯이 MySQL은 웹 애플리케이션에 적합한 빠른 성능과 사용 편의성을 제공하지만, 복잡한 쿼리와 트랜잭션 처리에는 제한적이며 일부 엔진은 ACID를 완벽히 지원하지 않습니다. ACID 규정 준수는 데이터베이스 관리 시스템이 트랜잭션을 안전하고 신뢰할 수 있게 처리하도록 보장하는 중요한 표준입니다. ORDBMS(객체 관계형 데이터베이스 관리 시스템)는 데이터를 객체처럼 관리할 수 있어 복잡한 데이터 관계를 효과적으로 표현할 수 있습니다. 반면, PostgreSQL은 복잡한 쿼리 처리와 데이터 무결성을 보장하는 강력한 ACID 및 트랜잭션 지원을 제공하며, 확장성이 뛰어나고 다양한 프로그래밍 언어와의 통합을 지원합니다. 그러나 사용법이 복잡하고 더 많은 리소스를 소모할 수 있습니다. 따라서 프로젝트의 특성에 따라 적절한 데이터베이스 선택이 중요합니다.</p><h3>MySQL과 PostgreSQL의 인기도와 선호도</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jbM55Xi0WYMOf4rgGX9odQ.png" /><figcaption>dbengine.com</figcaption></figure><figure><img alt="ddd" src="https://cdn-images-1.medium.com/max/1024/1*7u7fYKoEDKVMwJOCQEPocw.png" /><figcaption>stackoverflow 2023</figcaption></figure><p>데이터베이스 관리 시스템(DBMS)은 기술 스택의 핵심 요소로, 데이터 중심의 애플리케이션에서 중추적인 역할을 수행합니다. 최근 공개된 DB-Engines와 stackoverflow 설문조사 데이터를 통해 MySQL과 PostgreSQL의 인기와 선호도를 비교해보겠습니다.</p><h4>DB-Engines 순위</h4><p>DB-Engines의 2024년 6월 순위에 따르면, Oracle이 여전히 1위를 차지하고 있으며, MySQL은 2위, PostgreSQL은 4위에 랭크되어 있습니다. MySQL은 전체 점수에서는 높지만, 최근 몇 달 사이에 약간의 점수 하락을 겪었습니다. 반면, PostgreSQL은 점수가 증가하며 안정적인 성장세를 보이고 있습니다.</p><h4>개발자 선호도</h4><p>개발자 커뮤니티 내에서의 선호도를 살펴보면, PostgreSQL이 전문 개발자 사이에서 더 높은 선호도를 기록하고 있습니다. PostgreSQL은 전체 응답자 중 45.55%의 지지를 받으며 1위를 차지했으며, MySQL은 41.09%로 그 뒤를 이었습니다. 이는 PostgreSQL이 제공하는 고급 기능과 확장성 덕분으로 보입니다.</p><h4>기술적 특성 비교</h4><p>MySQL은 사용의 용이성과 빠른 성능으로 인기가 높으며, 웹 개발과 소규모 프로젝트에 적합한 선택으로 간주됩니다. 반면, PostgreSQL은 복잡한 쿼리 처리와 데이터 무결성을 중시하는 대규모 및 기업급 애플리케이션에 더 적합하며, 다양한 데이터 유형과 고급 인덱싱 기능을 지원합니다.</p><h3>실제 사용 사례를 통한 선택 가이드</h3><p><strong>MySQL</strong>은 주로 읽기 작업에 최적화된 데이터베이스로 알려져 있습니다. 가벼운 구조로 인해 읽기 전용 쿼리에서 빠르고 안정적인 성능을 제공합니다. 다양한 스토리지 엔진과의 호환성이 높아 웹 애플리케이션과 같이 동시성이 크게 요구되지 않는 경우에 적합합니다. 그러나 복잡한 트랜잭션이나 대용량 데이터 처리에는 제한이 있을 수 있습니다.</p><p><strong>PostgreSQL</strong>은 객체 관계형 데이터베이스 관리 시스템(ORDBMS)으로, 복잡한 읽기-쓰기 작업과 대규모 데이터 세트에 탁월합니다. PostgreSQL은 ACID 규정을 완벽히 준수하며, 고급 인덱싱 기능과 다양한 프로그래밍 언어의 통합 지원을 제공합니다. 이로 인해 엔터프라이즈 시스템, 데이터 웨어하우스, 그리고 공간 데이터베이스에서 자주 사용됩니다.</p><p>두 시스템 모두 강력한 커뮤니티 지원과 지속적인 개발이 이루어지고 있어, 선택 시 개발 환경과 특정 요구 사항을 고려하는 것이 중요합니다. 예를 들어, 단순하고 빠른 솔루션을 원한다면 MySQL이, 더 복잡하고 기능적으로 풍부한 데이터베이스가 필요하다면 PostgreSQL을 선택하는 것이 좋습니다. 각 데이터베이스 시스템의 장단점을 이해하고 프로젝트의 요구에 맞추어 적절한 선택을 하는 것이 중요합니다.</p><h3>결론</h3><p>프로젝트의 요구 사항에 따라 MySQL은 단순하고 빠른 해결책을 제공하는 반면, PostgreSQL은 더 복잡하고 데이터 무결성을 요구하는 대규모 애플리케이션에 적합합니다. 선택 시, 이러한 요소들을 고려하여 당면한 문제에 가장 적합한 데이터베이스를 선택하세요.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d8f1ac631b39" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[비동기(Asynchronous) 프로그래밍]]></title>
            <link>https://eheh34w.medium.com/%EB%B9%84%EB%8F%99%EA%B8%B0-asynchronous-%ED%94%84%EB%A1%9C%EA%B7%B8%EB%9E%98%EB%B0%8D-a62c14f0e240?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/a62c14f0e240</guid>
            <category><![CDATA[asynchronous]]></category>
            <category><![CDATA[javascript]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Mon, 03 Jun 2024 05:28:06 GMT</pubDate>
            <atom:updated>2024-06-03T05:28:06.069Z</atom:updated>
            <content:encoded><![CDATA[<h4>비동기란?</h4><blockquote>Event Driven,Non Blocking I/O</blockquote><p>앞에서 행하여진 사상(事象)이나 연산이 완료되었다는 신호를 받고 비로소 특정한 사상이나 연산이 시작되는 방식. [네이버 국어사전]</p><p>즉, 비동기 프로그래밍이란 특정 코드의 처리가 완료되기 전, 처리하는 도중에도 아래로 계속 내려가며 수행을 하는 것이다.</p><p>예를 들어</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/295/1*EuS6s_SWSQ3I_iAAzpRzvA.png" /></figure><p>짜장면 집에서 웨이터가 테이블1의 손님의 주문을접수하고 주방장에게 메뉴를 말하고 나올떄까지 기다리는것이 Blocking이다 하나의 일을 순차적으로 끝날떄까지 하는것이다. 동기적인 작업이다</p><p>여기서 비동기(Non Blocking)는 웨이터가 테이블1의 주문을 받고 주방장에게 갖다가 테이블2의 손님에게 가서 주문을 받아서 주방장에게 가서 주문하는것 그리고 요리가 나올시 손님에게 갖다주는 것이다.</p><p>Node.js 에서 프로그래밍적으로 본다면</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/337/1*Qiz-XLYuTujxG4EadFeGBg.png" /></figure><p>call stack : 한번에 여러일을 할수있게 하는 것(웨이터)</p><p>apis : (주문) : call stack 을 실행(run)을 해주는곳(주문)</p><p>Callback Queue(Event Queue, Task Queue) : APIs 에서 보내진 비동기 처리가 모이는 곳으로 콜 스택과는 다르게 선입선출 되는 특징을 가진다.<br>여기 모인 비동기함수는 이제부터 이벤트 루프의 감시하에 놓이게 된다.</p><p>Event Loop : 제일 중요한 녀석인데 Event Loop는 단 한개의 임무만을 수행한다.바로 Call Stack과 Queue에를 감시하는 일이다. 감시하다가 Call Stack이 비게 되면 Queue에 쌓인 비동기 함수를 Call Stack으로 보내주는 역할을 한다.Call Stack이 비어있을 때 Callback Queue 에 쌓여있는 비동기 함수 중 가장 먼저 들어온 함수를 보내준다.</p><ul><li>이러한 행동을 틱(tick)이라 부른다.</li><li>이벤트 루프를 통해 비로소 동기 함수와 비동기 함수의 순서가 정해진다.</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a62c14f0e240" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[24년 jira 기본 사용법]]></title>
            <link>https://eheh34w.medium.com/24%EB%85%84-jira-%EA%B8%B0%EB%B3%B8-%EC%82%AC%EC%9A%A9%EB%B2%95-265658be4853?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/265658be4853</guid>
            <category><![CDATA[developer]]></category>
            <category><![CDATA[pm]]></category>
            <category><![CDATA[sprint]]></category>
            <category><![CDATA[jira]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Mon, 25 Mar 2024 00:07:22 GMT</pubDate>
            <atom:updated>2024-03-25T00:07:22.282Z</atom:updated>
            <content:encoded><![CDATA[<h3>1. 이슈 유형과 관계도</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*cNwge2Pmnr_cbGw3Nr1hPA.png" /></figure><h3>1–1. 에픽 (Epic)</h3><ul><li>에픽이란 큰 단위의 작업을 의미한다. 하나의 스프린트에 걸쳐 끝나지 않고 여러 스프린트에 걸쳐서 종료된다. 프로젝트의 주요 기능을 대표하게 되며, 여러 스토리와 작업을 포함할 수 있다.</li></ul><h3>1–2. 스토리 (Story)</h3><ul><li>사용자 관점에서 본 기능이나 요구사항을 뜻한다.</li><li>일반적으로 <strong>“As a 사용자 유형, I want 어떤 기능(행위/목표) so that 어떤 이익(이유)”</strong>으로 작성된다.</li><li>기술적 전문용어가 아닌 비즈니스 언어로 작성하는것이 좋다.</li></ul><h3>1–3. 작업 (Task)</h3><ul><li>에픽 혹은 스토리의 하위작업으로 수행해야하는 구체적인 활동을 말한다.</li><li>개발 작업, 디자인 작업 등 다양한 형태를 취할 수 있다.</li></ul><h3>1–4. 하위 작업 (Sub Task)</h3><ul><li>스토리 혹은 태스크의 하위 작업으로 작업을 더 작은 단위로 나눈 것들 이다.</li></ul><h3>1–5. 버그 (Bug)</h3><ul><li>서비스에서 발생하는 문제점 또는 리포팅된 버그를 말한다.</li></ul><h3>2. <strong>스토리와 태스크의 차이점</strong></h3><p>전통적인 애자일 방식에는 스토리 밑에 태스크가 있고 그 밑에 하위 태스크가 있다. 하지만 Jira에서는 그렇게 작동하지 않는다. 스토리와 태스크는 부모 자식 관계가 아닌 형제의 관계로 이루어져 있었다.<br>스토리와 태스크를 어떻게 정의하고 구분 지어야 할지 궁금해서 아래 유튜브 영상을 참고하여 정리를 해 보았다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/32/0*luevSj89_f4zkCuV.png" /></figure><p><a href="https://www.youtube.com/watch?v=df_F5NWx1dc&amp;t=457s">When to use Story vs Tasks</a></p><h3>2–1. 스토리를 정의</h3><ul><li>스토리는 비즈니스 가치 또는 사용자 가치를 창출하는 작업을 의미한다.</li><li>고객이나 사용자에게 직접적인 가치를 제공하는 기능 개발에 초점을 맞추게 된다.</li></ul><h3>2–2. 작업을 정의</h3><ul><li>팀에서 수행하거나 실행해야하는 작업을 정의한다.</li><li>이는 직접적인 비즈니스 가치는 없지만 프로젝트 수행에 필요한 기술적, 관리적 작업을 포함한다.</li><li>작업의 결과가 수익을 창출하지 않으며 결과가 고객에게 전달되지 않는 작업이다.</li><li>예를 들어 AWS작업이나, 도커나 쿠버네티스를 설정하는 등의 작업을 말한다.<br>이러한 작업들은 일반적으로 수행해야하는 작업이며 팀에는 가치가 있지만 비즈니스적인 가치가 있는것은 아니다.</li></ul><p>즉, 사용자 관점의 비즈니스 요구사항은 스토리로, 비즈니스가치가 없는 기술적 관리적 기능 개발은 태스크로 설정하는 것 이라고 생각이 된다.</p><h3><strong>3. 워크플로우</strong></h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*wCeSRG-nDFWmIYW0o_JS_w.png" /></figure><p>현제 모든 작업은 생성하면 TO DO 에서 시작해서 → 작업중 → 리뷰 → 완료 순으로 플로우 가 설정 되어 있습니다</p><p>생성시 reviwer 를 선택하시면 리뷰로 넘어가면 슬랙에서 웹훅으로 알람이 갑니다 확인후 리뷰자가 리뷰후 작업완료를 넘기시거나 조금 부족한 부분이 있을경우 다시 재작업으로 돌려 작업중으로 하면 됩니다</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=265658be4853" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[pocketbase 시작하기]]></title>
            <link>https://eheh34w.medium.com/pocketbase-%EC%B2%B4%ED%97%98%EA%B8%B0-7940df567476?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/7940df567476</guid>
            <category><![CDATA[backend]]></category>
            <category><![CDATA[pocketbase]]></category>
            <category><![CDATA[database]]></category>
            <category><![CDATA[services]]></category>
            <category><![CDATA[golang]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Tue, 20 Feb 2024 06:59:25 GMT</pubDate>
            <atom:updated>2024-02-20T07:09:02.979Z</atom:updated>
            <content:encoded><![CDATA[<p>간단하게 백앤드 서버를 구축할 수 있고, 비용도 저렴한 서비스를 찾는 도 중 pocketbase를 알게 되었다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*5thCrYMoBbqfBeGuoEsw4Q.png" /></figure><h3><strong>pocktbase란?</strong></h3><p>Go 언어로 작성된 단 하나의 파일로 구성된 벡엔드 어플리케이션인데요. 기본적으로 인증, 데이터베이스 (Sqlite), 스토리지 기능까지 모두 들어가 있어서 아주 간편하게 벡엔드 서비스를 구축할 수 있습니다.</p><h3>다양한 프론트엔드 프레임워크 지원</h3><p>플러터, 스벨트, VUE, React, Angular 등 다양한 프레임워크를 지원한다고 소개되고 있습니다만, 백엔드 API 를 빠르게 구축할 수 있도록 구성되어있는 어플리케이션이기때문에, REST API 방식으로 통신할 수 있는 모든 서비스들이 가능하다고 볼 수 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/662/0*V6-mxHiuZx79QfKm.png" /></figure><p>자바스크립트 SDK와 Dart SDK를 지원하기 때문에 웹어플리케이션 뿐 아니라 모바일 어플리케이션에 대한 대응도 염두에 두고 개발된 모양입니다.</p><p><strong>Docker file로 구성하여</strong> <strong>실행하기</strong></p><h3><strong>1단계: Dockerfile 작성</strong></h3><p>먼저, PocketBase를 실행하기 위한 Dockerfile을 작성해야 합니다. Dockerfile은 Docker 이미지를 빌드하는 데 필요한 지침을 포함합니다. 다음은 PocketBase용 간단한 Dockerfile 예제입니다:</p><pre># 기본 이미지로 alpine 사용<br>FROM alpine:latest<br># 작업 디렉토리 설정<br>WORKDIR /app<br># PocketBase 바이너리 다운로드 (Linux AMD64 버전)<br>ADD https://github.com/pocketbase/pocketbase/releases/download/v0.21.3/pocketbase_0.21.3_linux_amd64.zip /app/pocketbase.zip<br># unzip 설치 및 바이너리 압축 해제<br>RUN apk add - no-cache unzip &amp;&amp; \<br> unzip /app/pocketbase.zip -d /app &amp;&amp; \<br> chmod +x /app/pocketbase &amp;&amp; \<br> rm /app/pocketbase.zip<br># 포트 8090 열기<br>EXPOSE 8090<br># PocketBase 실행<br>CMD [&quot;/app/pocketbase&quot;, &quot;serve&quot;, &quot; - http=0.0.0.0:8090&quot;]</pre><p>이 Dockerfile은 PocketBase의 최신 Linux AMD64 바이너리를 다운로드하고, 실행 권한을 부여한 후, 8090 포트에서 PocketBase를 실행합니다.</p><h3>2단계: Docker 이미지 빌드</h3><p>Dockerfile을 작성한 후, 해당 파일이 있는 디렉토리에서 다음 명령어를 사용하여 Docker 이미지를 빌드할 수 있습니다:</p><pre>docker build -t pocketbase .</pre><p>이 명령어는 현재 디렉토리(.)의 Dockerfile을 사용하여 pocketbase라는 이름의 Docker 이미지를 빌드합니다.</p><h3>3단계: Docker 컨테이너 실행</h3><p>이미지가 성공적으로 빌드되면, 다음 명령어를 사용하여 PocketBase Docker 컨테이너를 실행할 수 있습니다</p><pre>docker run -d -p 8090:8090 --name pocketbase pocketbase</pre><p>이 명령어는 pocketbase 이미지를 사용하여 pocketbase라는 이름의 컨테이너를 백그라운드(-d)에서 실행하고, 호스트의 8090 포트를 컨테이너의 8090 포트에 바인딩합니다.</p><p>이제 PocketBase가 Docker 컨테이너 내에서 실행되며, 브라우저를 통해 <a href="http://127.0.0.1:8090/_/">http://localhost</a>:8090/_/에 접속하면 PocketBase의 웹 admin 데시보드 UI에 접근할 수 있습니다.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KKxPgXDiIvn5ITBO9mFaBw.png" /></figure><p>먼저 admin 계정을 만든 후 접속을 하면</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*XWULsttgXpcymGY7yD_puA.png" /></figure><p>user 테이블이 기본적으로 생성이 되어있고 오른쪽 상단 API Preview 를 통해 api관련 해서 볼수가 있습니다.</p><p>New collection 을 통해 컬렉션이 생성이 되면 자동적으로 crud는 되는 것 같다. 이렇게 쉽게 백서비스를 구성할수가 있고 유저 인증 및 auth2 까지 기본적으로 사용할수가 있어서 스타트업에서나 개인 포트폴리오 할때 유용하게 사용할수있을 것 같다</p><p><strong>주요 다른 서비스와 비교</strong></p><p>PocketBase vs Supabase vs firebase 단순 표로 비교 해보았다</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/628/1*hwEHaSfe_TmE5_VMkfvMtg.png" /></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/633/1*2Je93ncQQ8ADq4ECyHpGLg.png" /></figure><p>장단점이 있기 떄문에 각자의 개발환경에 맞게 사용하는 것을 추천한다</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7940df567476" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Python 기본문법(자료형과 변수)]]></title>
            <link>https://eheh34w.medium.com/python-%EA%B8%B0%EB%B3%B8%EB%AC%B8%EB%B2%95-%EC%9E%90%EB%A3%8C%ED%98%95%EA%B3%BC-%EB%B3%80%EC%88%98-44e475e9688c?source=rss-e8494f8cfefc------2</link>
            <guid isPermaLink="false">https://medium.com/p/44e475e9688c</guid>
            <category><![CDATA[basic-python]]></category>
            <category><![CDATA[data]]></category>
            <category><![CDATA[variables]]></category>
            <category><![CDATA[python]]></category>
            <dc:creator><![CDATA[Turtle]]></dc:creator>
            <pubDate>Thu, 01 Jul 2021 11:13:40 GMT</pubDate>
            <atom:updated>2021-07-01T11:13:40.713Z</atom:updated>
            <content:encoded><![CDATA[<h3>자료형이란?</h3><p>프로그래밍에서 <strong>자료형(data type)</strong>은 값을 담는 그릇이라고 볼 수 있는데, <strong>파이썬(Python)</strong>에서는 크게숫자형, 문자열, 불린형 자료형으로 구분 합니다.</p><h4>숫자형</h4><p>숫자형은 말그대로 숫자를 나타내는 형으로 정수형과 실수형이 있습니다 정수형은 소수점이 없는 수를 말하고 실수형은 소수점이 있는 수를 말합니다</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/552/1*JMfomAIaxFT-UpPCQilvfw.png" /></figure><h3>문자열</h3><p>문자열을 나열한 자료형 입니다. ”(큰따옴표) 또는 ‘(작은따옴표)로 문자열의 시작과 끝을 나타냅니다</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/426/1*MgH7G0cYLAnvFIEc8CCxzA.png" /></figure><h3>불린형</h3><p>참 또는 거짓을 가리키는 자료형입니다 True or False</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/356/1*uZGK5BF7xz4WhZukC0bZfQ.png" /></figure><h3>변수란?</h3><p>앞서 언급했던 자료형들을 저장할 수 있는 공간이며 언제든지 데이터를 변경할 수 있다</p><p><strong>변수를 만드는 방법은 간단하다 </strong><br><em>변수이름 = 데이터 의 형태로 만들면 된다</em><br><em>= 의 의미는 할당연산자로써 오른쪽에 있는 데이터를 왼쪽에 있는 변수에 저장한다는 의미 입니다</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/650/1*DzNLbzYDrBFwvf6yeWobHA.png" /></figure><p><em>변수에 저장된 데이터를 변경하기</em></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/602/1*wolA_zrHjnAL8MB5dw9Hfg.png" /></figure><p><strong>변수의 이름을 짓는 규칙이 있습니다</strong></p><ul><li><em>데이터를 표현할 수 있는 이름으로 짓는다.</em></li><li><em>문자부터 시작해야 한다.</em></li><li><em>대소문자는 구분한다.</em></li><li><em>로 시작할 수 있다.</em></li><li><em>미리 예약된 키워드는 사용할 수 없다.</em></li></ul><p>이렇게 간단하게 파이썬 기초문법인 자료형과 변수를 알아보았습니다. 다음 시간에는 연산과 연산자에 대하여 알아보겠습니다.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=44e475e9688c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>