Week01 - Rust의 기본 개념 및 컨셉 (Java, Python 과의 비교)

드디어 말로만 들었고, 기다렸던 Rust에 대해서 첫 수업을 들었다. 일단 첫 만남에 대한 소감은 꽤나 정교하게 설계가 된 언어라는 점이다.

Rust는 시스템 프로그래밍 언어로, 메모리 안전성과 병렬 프로그래밍에 중점을 둔다. 2010년에 Mozilla에서 처음 개발되었으며, Rust의 주요 목표는 잘못된 메모리 참조나 데이터 경쟁 등의 버그 없이 효율적인 코드를 작성할 수 있게 하는 것이다.

이번 포스팅에서는 내가 기존에 배우고 사용해왔던 자바, 파이썬과 비교를 하면서 접근하려 한다. 그리고 필요하다면 C++과도 비교를 해볼 생각이다.

Rust와 다른 언어의 차별화된 점

• 메모리 안전성
• 컴파일 시점에서 메모리 관련 오류를 잡아내기 때문에, C++처럼 메모리 관리에 신경을 쓸 필요가 없다.
• 병렬성
• 데이터 경쟁을 방지하기 위한 풍부한 타입 시스템을 가지고 있다.
• Immutability
• 기본적으로 모든 변수가 불변(immutable)이다.
• Pattern Matching
• 강력한 패턴 매칭 기능을 지원한다.
• Zero-Cost Abstraction
• 추상화가 성능에 영향을 미치지 않는다.

메모리 안정성

자바나 파이썬은 컴파일 시점에서 Rust처럼 메모리 관련 오류를 철저하게 잡아내지는 않는다. 이들 언어는 메모리 관리에 대한 접근 방식이 다르기 때문에, Rust의 메모리 안전성과 직접 비교하기는 어렵다.

자바

자바는 가비지 컬렉터(Garbage Collector)를 이용해 런타임에서 자동으로 메모리를 관리한다. 그래서 개발자가 명시적으로 메모리를 해제하거나 할당할 필요가 없다. 그러나 이 방식은 런타임에서 메모리 누수가 발생할 가능성을 완전히 제거하지는 못한다. 또한, 자바는 배열 범위를 넘어서는 인덱스에 접근하려고 할 때 런타임 예외를 발생시키는 등의 방법으로 메모리 안전성을 일정 부분 유지한다. 하지만 이것은 컴파일 시점의 검사가 아니라 런타임 검사다.

파이썬

파이썬도 가비지 컬렉션을 사용하여 런타임에서 메모리를 관리한다. 파이썬은 동적 타입 언어로, 런타임에서 타입이 결정되므로 컴파일 시점에서 메모리 안전성을 체크하기는 더 어렵다. 배열 범위를 초과하는 인덱스에 접근하려고 하거나 null 참조 등의 오류는 런타임에서 예외를 발생시킨다.

C++

C++는 일부 메모리 관련 오류를 컴파일 시점에서 검사할 수 있지만, Rust처럼 체계적이고 강력한 메모리 안전성 검사를 제공하지는 않는다. C++의 경우 다음과 같은 문제점이 있을 수 있다. (사실, 아직은 내가 C++에 대해서는 잘 모르기 때문에 우선 이렇게 조사한 내용을 정리만 해두고 나중에 본격적으로 공부할 때 내용 추가를 해보겠다.)

• Null 참조
• C++에서는 null 포인터를 통한 참조가 가능하며, 이것은 런타임 에러를 발생시킬 수 있다. Rust에서는 이를 컴파일 시점에서 방지한다.
• 메모리 누수와 해제 오류
• C++에서는 개발자가 직접 메모리를 할당하고 해제해야 한다. new와 delete 등의 연산자를 통해 메모리를 관리하는데, 이 과정에서 메모리 누수나 더블 프리(double free)와 같은 문제가 발생할 수 있다.
• 데이터 경쟁과 동시성 오류
• C++의 멀티스레딩 모델은 상대적으로 기본적이며, 데이터 경쟁이 발생할 수 있다. Rust는 이러한 문제를 타입 시스템을 통해 컴파일 시점에서 방지한다.
• 배열 범위 초과
• C++에서 배열의 인덱스 범위를 초과하는 접근은 컴파일 시점에서 잡히지 않고, 이는 런타임 에러를 발생시킬 수 있다. Rust에서는 이런 문제를 컴파일 시점이나 런타임 시점에서 체크한다.

C++는 성능과 유연성에 초점을 맞춘 언어라 메모리를 매우 저수준에서 관리할 수 있지만, 그만큼 개발자에게 높은 주의와 경험이 요구된다. 반면 Rust는 메모리 안전성을 컴파일 시점에서 강력하게 검사하여, 상대적으로 안전하면서도 높은 성능을 유지할 수 있다.

Rust

반면에 Rust는 컴파일러가 메모리 안전성을 검사하고, 예를 들어 데이터 경쟁(data race)이나 null 참조와 같은 일반적인 문제를 컴파일 시점에서 잡아낸다. 이렇게 해서 런타임 오류의 가능성을 크게 줄일 수 있다.

즉, 자바나 파이썬은 메모리 관리를 자동화하여 개발자의 부담을 줄이지만, 이로 인해 런타임에서 발생할 수 있는 문제들을 완전히 제거하지는 못한다. Rust는 이런 문제를 컴파일 시점에서 잡아내어 런타임에서의 메모리 관련 문제를 최소화한다.

Rust는 타입 시스템, 소유권(ownership) 모델, 빌림(borrowing)과 라이프타임(lifetime) 같은 여러 언어 기능을 활용하여 컴파일 시점에 메모리 안전성을 검사한다. 이러한 메커니즘들이 서로 결합되어 작동하여, 코드가 실행되지 않아도 다양한 종류의 메모리 관련 오류를 미리 잡아낼 수 있다.

• 소유권(Ownership)
• Rust에서 모든 변수에는 '소유자'가 있고, 하나의 값에는 한 번에 하나의 소유자만 있을 수 있다. 이 소유권의 개념을 통해 메모리 해제 시점이 명확해지고, 메모리 누수나 더블 프리(double free)와 같은 문제를 예방한다.
• 빌림(Borrowing)과 라이프타임(Lifetime)
• 소유권 외에도 '빌림'과 '라이프타임'이라는 개념이 있다. 빌림은 변수의 소유권을 일시적으로 다른 코드에 넘기는 것이고, 라이프타임은 이 빌림이 얼마나 지속되는지를 나타낸다. 이를 통해 댕글링 포인터(dangling pointer)나 미정의 동작(undefined behavior)을 예방한다.
• 타입 시스템
• Rust의 타입 시스템은 매우 강력하다. 이를 통해 예를 들면, null 값이 가능한 타입과 그렇지 않은 타입을 구분할 수 있으며, 이러한 정보를 사용해 컴파일 시점에 null 참조 문제를 잡아낼 수 있다.

fn main() {
    let mut x = 5;
    let y = &mut x;
    let z = &mut x; // 컴파일 에러: mutable borrow occurs here
    *y += 1;
    println!("{}", x); // y가 x를 빌려간 상태에서 x에 접근하려고 하면 컴파일 에러 발생
}

위 코드에서는 x에 대한 뮤터블 참조 y와 z를 동시에 만들려고 하므로 컴파일 에러가 발생한다. 이러한 검사를 통해 데이터 경쟁을 예방한다.

이렇게 Rust의 여러 언어 기능들이 상호 작용하면서 컴파일 시점에서 메모리 관련 오류를 효과적으로 잡아낼 수 있다. 코드를 실행하지 않고도 이러한 검사가 가능한 것은 이러한 언어 기능들이 수학적 논리와 형식적 검증에 기반을 둠으로써 가능하다.

데이터 경쟁이란?

데이터 경쟁(data race)은 멀티스레딩 환경에서 두 개 이상의 스레드가 동시에 같은 메모리 위치에 접근하려고 할 때 발생하는 문제다. 이러한 상황에서 적어도 하나의 스레드가 데이터를 수정하려고 하면, 메모리의 상태는 예측 불가능하게 될 수 있다. 데이터 경쟁은 다음 세 가지 조건이 동시에 충족될 때 일어난다:

1. 두 개 이상의 스레드가 동시에 같은 데이터에 접근한다.
2. 그 중 적어도 하나의 스레드가 데이터를 수정한다.
3. 해당 접근이 동기화되지 않는다.

간단한 예로, 두 스레드가 동시에 같은 변수 x를 증가시키려고 한다고 생각해보자. x의 초기값이 0이라고 하면, 두 스레드가 실행을 완료한 후에 x의 값이 2가 될 것으로 예상할 수 있다. 그러나 데이터 경쟁이 발생하면, 두 스레드가 거의 동시에 x의 현재 값을 읽어 1 증가시킨 후 다시 저장할 수 있다. 이런 경우에는 x의 값이 1이 될 수도 있다.

Rust에서의 해결책

Rust는 컴파일 시점에서 이러한 데이터 경쟁을 방지한다. mut 키워드를 사용하여 데이터가 변경 가능한지 명시하고, 러스트의 소유권(ownership) 및 빌림(borrowing) 모델을 통해 한 번에 하나의 스레드만이 데이터를 수정할 수 있게 한다. 이러한 방법으로 Rust는 컴파일 시점에서 데이터 경쟁을 방지한다.

왜 중요한가?

데이터 경쟁은 심각한 버그를 유발할 수 있고, 디버깅이 매우 어렵다. 실제로 이 문제로 인해 어플리케이션의 불안정성, 성능 저하, 보안 취약점 등 다양한 문제가 발생할 수 있다. 따라서 데이터 경쟁을 사전에 방지하는 것은 매우 중요하다.

"추상화가 성능에 영향을 미치지 않는다"의 의미

"추상화가 성능에 영향을 미치지 않는다"라는 말은 추상화 레벨이 높아져도 그로 인한 성능 저하가 없거나 미미하다는 것을 의미한다. 즉, 코드가 사람이 이해하기 쉽도록 단순화되거나 고수준의 연산으로 표현되더라도, 그것이 실행 속도나 메모리 사용량에 큰 부담을 주지 않는다는 것이다.

추상화와 성능의 전형적인 상충 관계

보통 프로그래밍에서는 추상화 레벨이 높아질수록 성능에 부정적인 영향을 미칠 가능성이 높다. 예를 들어, Java나 Python과 같은 고수준 언어는 개발자가 쉽게 코드를 작성할 수 있게 해주지만, 이로 인해 실행 속도가 느려질 수 있다. 또한 가비지 컬렉션, 동적 타이핑 등과 같은 메커니즘이 추가되면 그만큼 CPU나 메모리 사용량이 증가할 수 있다.

추상화와 성능이 상충하지 않을 때

그러나 일부 언어나 라이브러리, 프레임워크는 이러한 상충 관계를 잘 극복한다. 예를 들어, Rust는 메모리 안전성을 보장하면서도 C++에 버금가는 성능을 내는 것으로 알려져 있다. 이런 경우를 가리켜 "추상화가 성능에 영향을 미치지 않는다"고 표현할 수 있다.

왜 중요한가?

이러한 특성은 개발자가 성능을 크게 신경 쓰지 않고도 안정적이고 효율적인 코드를 작성할 수 있게 해준다. 따라서 개발 시간을 단축하고, 유지 보수가 쉽고, 버그 발생 가능성을 줄일 수 있다.

Rust와 Java/Python의 공통점

• 객체 지향
• Java와 마찬가지로, Rust도 메서드와 인스턴스의 개념을 가지고 있다.
• 타입 시스템
• Java나 C++과 비슷한 강타입 언어다.
• Package Management: 
• Python의 pip, Java의 Maven 같이 Rust도 패키지 관리를 위해 Cargo를 사용한다.

장점/단점

장점

• 메모리 안전성
• 높은 성능
• 병렬 처리에 유리

단점

• 학습 곡선이 높다
• 생태계가 아직 작다 (하지만 빠르게 성장 중)

산업 분야

• 웹 어셈블리: 빠른 성능이 필요한 프론트엔드 개발
• 시스템 프로그래밍
• OS나 브라우저 엔진 개발
• 임베디드 시스템
• IoT 디바이스
• 데이터베이스
• 높은 병렬 처리 능력이 필요한 곳

실제 애플리케이션 예시

• Firefox
• Mozilla에서 개발한 브라우저의 일부 컴포넌트는 Rust로 작성되어 있다.
• Discord
• 일부 서비스를 Rust로 리팩토링 했다고 공개적으로 언급했다

Rust는 비교적 새로운 언어지만 성장세가 빠르고, 특히 시스템 프로그래밍이나 병렬 처리, 메모리 안전성이 중요한 분야에서 주목받고 있다고 한다. 특히나 요즘 들어서는 C++을 대체하려는 움직임이 일어나고 있다는 이야기를 Senior 개발자들로부터 심심찮게 들을 수 있다. 그런 점에서 내가 BCIT CST의 옵션을 Programming Paradigms로 선택한 이유가 바로 여기에 있는 것이다. 이렇게 배우고 싶었던 언어이기에 비록 매우 어렵다는 이야기가 많지만, 한번 도전해보려 한다.