Rust on philipjkim

AI 에이전트 시대의 C 언어 Part 2: AI는 C를 살리는가, 대체하는가

Fri, 20 Mar 2026 14:09:55 +0900

이 글은 Claude Opus 4.6 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

들어가며

Part 1에서는 AI 에이전트 등장 이전에 이미 진행되고 있던 C 언어의 위상 변화를 살펴보았습니다. 메모리 안전성 논쟁, 정부 권고, 주요 프로젝트의 탈C 마이그레이션이 그 핵심이었습니다.

Part 2에서는 AI 코딩 에이전트 가 이 흐름에 어떤 영향을 미치고 있는지 분석합니다. 결론부터 말하면, AI는 C를 살리는 동시에 대체하고 있습니다. 이 역설적인 이중 현상 이 이 글의 핵심 주제입니다.

1. AI가 C 개발을 돕는 방식: “더 안전한 C”

Linux 커널의 AI 코드 리뷰

세계 최대 C 코드베이스인 Linux 커널에서도 AI 도구가 활용되기 시작했습니다. Btrfs 개발자 Chris Mason은 2026년 초 review-prompts 프로젝트를 시작했습니다. Claude Code 등 AI 도구를 활용해 커널 패치를 리뷰하는 프롬프트 모음으로, 대형 diff를 작은 단위로 분할해 C 특유의 문제점을 효과적으로 잡아냅니다.

AI 에이전트 시대의 C 언어 Part 1: 흔들리는 위상과 새로운 도전자들

Fri, 20 Mar 2026 14:08:55 +0900

이 글은 Claude Opus 4.6 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

들어가며

C 언어는 1972년 탄생 이래 50년 넘게 시스템 프로그래밍의 근간이었습니다. Linux 커널, Windows, macOS, PostgreSQL, Python 런타임, nginx — 우리가 매일 쓰는 소프트웨어의 토대 상당 부분이 C로 작성되어 있습니다.

그러나 최근 몇 년간 C 언어의 입지에 큰 변화가 일어나고 있습니다. 메모리 안전성 문제를 둘러싼 논쟁이 격화되고, 미국 정부 기관이 공식적으로 C 사용을 자제하라고 권고하며, Rust를 비롯한 대안 언어들이 빠르게 성장하고 있습니다. 여기에 2024년부터 본격화된 AI 코딩 에이전트(Claude Code, Codex, Gemini CLI 등) 의 등장은 이 흐름을 더욱 가속하고 있습니다.

Go to Rust: #10. 프로젝트 관리와 실전 패턴

Mon, 19 Jan 2026 16:10:08 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

이 마지막 섹션에서는 실제 Rust 프로젝트를 구성하고 관리하는 방법을 학습합니다. Cargo 심화, 모듈 시스템, 테스트, 그리고 Go 코드를 Rust로 포팅할 때 유용한 패턴들을 다룹니다.

10.1 Cargo 심화

Cargo.toml 상세 설정

[package]
name = "myapp"
version = "0.1.0"
edition = "2021"
authors = ["Your Name <you@example.com>"]
description = "A sample Rust application"
license = "MIT"
repository = "https://github.com/you/myapp"
keywords = ["cli", "tool"]
categories = ["command-line-utilities"]

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

[dev-dependencies]
criterion = "0.5" # 벤치마크용

[build-dependencies]
cc = "1.0" # 빌드 스크립트용

[features]
default = ["json"]
json = ["serde_json"]
full = ["json", "yaml"]

[[bin]]
name = "myapp"
path = "src/main.rs"

[[bin]]
name = "mytool"
path = "src/bin/mytool.rs"

[profile.release]
opt-level = 3
lto = true

의존성 관리

[dependencies]
# 버전 지정
serde = "1.0" # ^1.0.0 (1.x.x)
serde = "=1.0.104" # 정확히 1.0.104
serde = ">=1.0, <2.0" # 범위

# Git 의존성
mylib = { git = "https://github.com/user/mylib" }
mylib = { git = "https://github.com/user/mylib", branch = "dev" }
mylib = { git = "https://github.com/user/mylib", tag = "v1.0.0" }
mylib = { git = "https://github.com/user/mylib", rev = "abc123" }

# 로컬 경로
mylib = { path = "../mylib" }

# 선택적 의존성
serde_json = { version = "1.0", optional = true }

# 피처 플래그
tokio = { version = "1", features = ["rt-multi-thread", "macros"] }

Go modules와 비교

# Go: go.mod
module github.com/user/myapp

go 1.21

require (
 github.com/gin-gonic/gin v1.9.0
 github.com/lib/pq v1.10.0
)

# Rust: Cargo.toml
[package]
name = "myapp"
version = "0.1.0"
edition = "2021"

[dependencies]
axum = "0.7"
sqlx = { version = "0.7", features = ["postgres"] }

측면	Go	Cargo
의존성 파일	go.mod	Cargo.toml
락 파일	go.sum	Cargo.lock
저장소	분산 (GitHub 등)	중앙 (crates.io)
버전 관리	Git 태그	SemVer

피처 플래그

[features]
default = ["std"]
std = []
alloc = []
json = ["serde", "serde_json"]
full = ["json", "yaml", "toml"]

// 조건부 컴파일
#[cfg(feature = "json")]
pub mod json {
 pub fn parse_json(s: &str) -> Value { /* ... */ }
}

#[cfg(feature = "std")]
use std::collections::HashMap;

#[cfg(not(feature = "std"))]
use alloc::collections::BTreeMap as HashMap;

10.2 모듈 시스템

파일 시스템과 모듈 구조

myapp/
├── Cargo.toml
└── src/
 ├── main.rs # 바이너리 루트
 ├── lib.rs # 라이브러리 루트
 ├── config.rs # config 모듈
 ├── utils/
 │ ├── mod.rs # utils 모듈
 │ ├── helpers.rs # utils::helpers
 │ └── format.rs # utils::format
 └── handlers/
 ├── mod.rs
 ├── user.rs
 └── post.rs

lib.rs:

Go to Rust: #9. 비동기 프로그래밍

Mon, 19 Jan 2026 16:09:59 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

Rust의 async/await는 Go의 goroutine과 근본적으로 다른 접근 방식입니다. Go는 런타임이 모든 것을 관리하지만, Rust는 명시적인 비동기 모델을 사용합니다. 이 섹션에서는 Rust의 비동기 생태계와 Tokio 런타임을 학습합니다.

9.1 비동기의 필요성

동기 vs 비동기

동기 (Synchronous):

// 순차적 실행, 블로킹
fn fetch_data() -> Data {
 let response = http_get("https://api.example.com"); // 대기
 parse(response)
}

비동기 (Asynchronous):

// 대기 중 다른 작업 가능
async fn fetch_data() -> Data {
 let response = http_get("https://api.example.com").await; // 양보
 parse(response)
}

Go의 goroutine 모델

Go는 런타임이 내장되어 있어 동기 코드처럼 보이지만 비동기로 동작합니다:

Go to Rust: #8. 동시성 프로그래밍

Mon, 19 Jan 2026 16:09:50 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

Rust의 “Fearless Concurrency"는 컴파일 타임에 데이터 레이스를 방지합니다. Go의 고루틴과 채널에 익숙하다면, Rust의 동시성 모델이 어떻게 다른지 이해하는 것이 중요합니다.

8.1 Rust의 동시성 철학

“Fearless Concurrency"란?

Go의 철학: “Don’t communicate by sharing memory; share memory by communicating.” Rust의 철학: “Fearless Concurrency through ownership.”

Go	Rust
런타임에 데이터 레이스 감지 (`-race`)	컴파일 타임에 데이터 레이스 방지
고루틴 + 채널 권장	소유권 + 타입 시스템으로 안전성 보장
공유 메모리도 가능 (주의 필요)	공유 메모리도 안전하게 사용 가능

데이터 레이스의 세 가지 조건

두 스레드가 같은 데이터에 접근
적어도 하나가 쓰기 작업
접근이 동기화되지 않음

Rust는 소유권 규칙으로 이를 컴파일 타임에 방지합니다:

Go to Rust: #7. 컬렉션과 이터레이터

Mon, 19 Jan 2026 16:09:42 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

Rust의 컬렉션은 Go와 유사한 기능을 제공하지만, 소유권 시스템과 결합되어 더 안전합니다. 특히 이터레이터 시스템은 Go의 range보다 훨씬 강력하며, 함수형 프로그래밍 스타일을 지원합니다.

7.1 표준 컬렉션 개요

Go와 Rust 컬렉션 매핑

Go	Rust	설명
`[]T` (slice)	`Vec<T>`	동적 배열
`[N]T` (array)	`[T; N]`	고정 배열
`string`	`String`	소유된 문자열
`string` (리터럴)	`&str`	문자열 슬라이스
`map[K]V`	`HashMap<K, V>`	해시 맵
-	`HashSet<T>`	해시 셋
-	`BTreeMap<K, V>`	정렬된 맵
-	`BTreeSet<T>`	정렬된 셋
-	`VecDeque<T>`	양방향 큐
`container/list`	`LinkedList<T>`	이중 연결 리스트

7.2 Vec 심화

생성 방법들

// 빈 벡터
let v: Vec<i32> = Vec::new();

// vec! 매크로 (가장 흔함)
let v = vec![1, 2, 3, 4, 5];

// 같은 값으로 초기화
let v = vec![0; 10]; // [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

// 용량 미리 할당
let mut v = Vec::with_capacity(100);

// 이터레이터에서 수집
let v: Vec<i32> = (1..=5).collect();

// from_iter
let v = Vec::from_iter([1, 2, 3]);

기본 연산

let mut v = vec![1, 2, 3];

// 추가
v.push(4); // 끝에 추가
v.insert(0, 0); // 인덱스에 삽입: [0, 1, 2, 3, 4]

// 제거
let last = v.pop(); // 끝에서 제거, Option<T>
let removed = v.remove(0); // 인덱스에서 제거, T
v.retain(|&x| x > 2); // 조건에 맞는 것만 유지

// 접근
let first = v[0]; // 패닉 가능
let first = v.get(0); // Option<&T>
let first = v.first(); // Option<&T>
let last = v.last(); // Option<&T>

// 수정
v[0] = 10;
if let Some(first) = v.first_mut() {
 *first = 20;
}

Go의 append vs Rust의 push

// Go: append는 새 슬라이스 반환 가능
slice := []int{1, 2, 3}
slice = append(slice, 4) // 재할당 가능

// 용량 확인
cap(slice)

// Rust: push는 in-place 수정
let mut v = vec![1, 2, 3];
v.push(4); // v가 mut이어야 함

// 용량
v.capacity();
v.reserve(100); // 추가 용량 확보
v.shrink_to_fit(); // 불필요한 용량 해제

소유권과 Vec

let v = vec![String::from("a"), String::from("b")];

// 인덱스 접근은 빌림
let first: &String = &v[0]; // 불변 빌림

// for 루프는 소유권 이동 또는 빌림 선택 가능
for s in v { // v의 소유권 이동, s: String
 println!("{}", s);
}
// v는 더 이상 사용 불가

let v = vec![String::from("a"), String::from("b")];
for s in &v { // v 빌림, s: &String
 println!("{}", s);
}
// v 여전히 사용 가능

for s in &mut v { // 가변 빌림, s: &mut String
 s.push_str("!");
}

슬라이싱

let v = vec![1, 2, 3, 4, 5];

// 슬라이스 참조
let slice: &[i32] = &v[1..4]; // [2, 3, 4]
let slice: &[i32] = &v[..]; // 전체

// 가변 슬라이스
let mut v = vec![1, 2, 3, 4, 5];
let slice: &mut [i32] = &mut v[1..4];
slice[0] = 20; // v는 [1, 20, 3, 4, 5]

7.3 문자열 처리

String vs &str

// String: 힙에 할당된 소유 문자열
let owned: String = String::from("hello");
let owned: String = "hello".to_string();
let owned: String = "hello".to_owned();

// &str: 문자열 슬라이스 (빌림)
let borrowed: &str = "hello"; // 정적 문자열
let borrowed: &str = &owned; // String에서 빌림
let borrowed: &str = &owned[0..3]; // 부분 슬라이스

특성	`String`	`&str`
소유권	있음	없음 (빌림)
힙 할당	예	아니오
가변	가능	불가능
크기	가변	고정 (뷰)
함수 인자	소유권 필요시	대부분

UTF-8 인코딩

Rust 문자열은 항상 유효한 UTF-8입니다:

Go to Rust: #6. 에러 처리

Mon, 19 Jan 2026 16:09:35 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

Rust의 에러 처리는 Go와 철학적으로 유사합니다. 두 언어 모두 예외(exception)를 사용하지 않고 명시적인 에러 반환을 선호합니다. 하지만 Rust는 타입 시스템을 통해 에러 처리를 강제하여, Go에서 흔히 발생하는 “에러 무시” 문제를 원천 차단합니다.

6.1 Rust의 에러 처리 철학

복구 가능한 에러 vs 복구 불가능한 에러

Rust는 에러를 두 가지로 구분합니다:

복구 가능한 에러 (Recoverable): Result<T, E>

파일을 찾을 수 없음
네트워크 연결 실패
잘못된 사용자 입력

복구 불가능한 에러 (Unrecoverable): panic!

Go to Rust: #5. 트레이트와 제네릭

Mon, 19 Jan 2026 09:56:15 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

트레이트(Trait)는 Rust의 다형성 메커니즘입니다. Go의 인터페이스와 비슷한 역할을 하지만, 구현 방식과 기능에서 큰 차이가 있습니다. 이 섹션에서는 트레이트와 제네릭을 Go와 비교하며 깊이 있게 학습합니다.

5.1 트레이트 기초

트레이트란?

트레이트는 타입이 구현해야 하는 메서드 집합을 정의합니다:

// 트레이트 정의
trait Summary {
 fn summarize(&self) -> String;
}

// 타입 정의
struct Article {
 title: String,
 author: String,
 content: String,
}

// 트레이트 구현
impl Summary for Article {
 fn summarize(&self) -> String {
 format!("{} by {}", self.title, self.author)
 }
}

Go interface vs Rust trait

가장 큰 차이: 암묵적 vs 명시적

Go to Rust: #4. 구조체, 열거형, 패턴 매칭

Mon, 19 Jan 2026 09:56:10 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

이 섹션에서는 Rust에서 데이터를 구조화하는 방법을 학습합니다. Go 개발자에게 구조체는 익숙하겠지만, Rust의 열거형(enum)은 Go의 const/iota보다 훨씬 강력하며, 패턴 매칭은 switch문을 완전히 새로운 수준으로 끌어올립니다.

4.1 구조체 (Struct)

구조체 정의와 인스턴스 생성

// 구조체 정의
struct User {
 username: String,
 email: String,
 sign_in_count: u64,
 active: bool,
}

// 인스턴스 생성
fn main() {
 let user = User {
 username: String::from("alice"),
 email: String::from("alice@example.com"),
 sign_in_count: 1,
 active: true,
 };
 
 // 필드 접근
 println!("Username: {}", user.username);
}

Go struct와의 문법 비교:

Go to Rust: #3. 소유권과 빌림 (Ownership & Borrowing)

Mon, 19 Jan 2026 09:56:03 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

소유권(Ownership)은 Rust의 가장 독특하고 중요한 개념입니다. Go의 가비지 컬렉션과 완전히 다른 접근 방식으로, 컴파일 타임에 메모리 안전성을 보장합니다. 이 섹션은 Rust 학습에서 가장 중요한 부분이므로 충분한 시간을 들여 이해하시기 바랍니다.

3.1 소유권이란 무엇인가?

메모리 관리의 세 가지 방식

프로그래밍 언어들은 메모리를 관리하는 방식이 다릅니다:

1. 가비지 컬렉션 (Go, Java, Python, JavaScript)

// Go: GC가 알아서 정리
func example() {
 slice := make([]int, 1000000)
 // 함수 종료 후 GC가 언젠가 정리
}

장점: 개발자가 메모리 관리 신경 안 써도 됨
단점: GC 일시 정지, 예측 불가능한 지연, 메모리 오버헤드

2. 수동 관리 (C, C++)

Go to Rust: #2. 기본 문법과 타입 시스템

Mon, 19 Jan 2026 09:55:56 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

이 섹션에서는 Rust의 기본 문법을 Go와 비교하며 학습합니다. Go 개발자에게 익숙한 개념들이 Rust에서 어떻게 표현되는지, 그리고 Rust만의 독특한 특징은 무엇인지 알아봅니다.

2.1 변수와 가변성

let vs var: 불변이 기본인 이유

Go에서는 변수가 기본적으로 가변(mutable)입니다:

// Go: 기본이 가변
x := 10
x = 20 // OK

Rust에서는 불변(immutable)이 기본입니다:

// Rust: 기본이 불변
let x = 10;
x = 20; // 컴파일 에러!

왜 불변이 기본일까요?

Go to Rust: #1. 시작하기 - Rust 소개와 환경 설정

Mon, 19 Jan 2026 09:55:50 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

Go 개발자로서 새로운 언어를 배우려면 먼저 그 언어가 왜 존재하는지, 어떤 문제를 해결하려고 하는지 이해하는 것이 중요합니다. 이 섹션에서는 Rust의 설계 철학을 Go와 비교하며 이해하고, 개발 환경을 설정한 뒤 첫 프로젝트를 생성해봅니다.

1.1 Rust는 왜 배워야 하는가?

Rust의 설계 철학

Rust는 Mozilla Research에서 시작되어 2015년에 1.0이 릴리스된 시스템 프로그래밍 언어입니다. Rust의 핵심 목표는 세 가지입니다:

안전성(Safety): 메모리 안전성을 컴파일 타임에 보장
속도(Speed): C/C++에 필적하는 성능
동시성(Concurrency): 데이터 레이스 없는 동시성 프로그래밍

Go도 비슷한 시기(2009년)에 등장했지만, 설계 목표가 다릅니다:

Go to Rust: #0. Overview

Mon, 19 Jan 2026 08:36:02 +0900

이 글은 Claude Opus 4.5 을 이용해 초안이 작성되었으며, 이후 퇴고를 거쳤습니다.

From Go to Rust: A Comprehensive Guide for Go Developers

Go 언어에 익숙한 개발자가 Rust를 체계적으로 학습할 수 있도록 구성된 가이드입니다. Go와의 비교를 통해 새로운 개념을 빠르게 이해하고, 실무에서 바로 적용할 수 있는 실용적인 내용을 담았습니다.

가이드의 특징

Go 개발자 관점: 모든 개념을 Go와 비교하여 설명, 익숙한 개념에서 출발
실용적 접근: 이론보다 실제 코드 예제 중심
점진적 난이도: 기초부터 고급까지 체계적 진행
실전 지향: 각 섹션에 Go ↔ Rust 코드 변환 예제 포함
함정 주의: Go 개발자가 흔히 하는 실수와 해결법 명시

섹션별 상세 목차

Section 1: 시작하기 - Rust 소개와 환경 설정

Rust의 설계 철학을 이해하고, Go와의 포지셔닝 차이를 명확히 합니다. 개발 환경을 설정하고 첫 프로젝트를 생성합니다.

번역글: Rust 의 목적성에 대한 질문과 답변

Mon, 08 Sep 2025 11:28:08 +0900

이 글은 Quora 에 Rust 관련 올라온 질문과 답변을 Gemini 를 통해 번역한 것입니다.

Q: Rust는 ‘메모리 안전성’보다는 Rust를 사용해 경력 있는 시니어 개발자들의 일을 값싼 주니어들이 해낼 수 있을 거라는 희망을 품고 그들을 고용하는 것과 더 관련이 있는 것 아닌가요? 제가 틀렸나요? Rust가 새로운 Ruby인가요?

A1 (Matt Laine의 답변):

어떤 프로그래밍 언어의 기능이든 홍보되는 데는 이유가 있습니다. 어떤 기능들은 언어 설계자가 멋지다고 생각해서 홍보되죠. 또 다른 기능들은 개발 속도를 높여준다거나, 특정 관리자들이 골치 아프다고 여기는 종류의 오류들을 제거해준다거나, 비즈니스에 도움이 되는 어떤 지표를 향상시켜 준다는 약속을 하는 것으로 해석될 수 있기 때문에 홍보됩니다. 또 어떤 기능들은 그저 과대광고를 철석같이 믿고 다른 사람들도 그렇게 해주기를 바라는 ‘언어 전도사들’에 의해 홍보되기도 합니다.