Rust는 실행성능, 병렬처리, 메모리보호 문제를 풀기위해 새로 만든 프로그래밍 랭귀지입니다. 최신 프로그래밍 랭귀지 요소들을 반영해서 완전히 새로 만듬으로써, Rust 창조자들은 전통적인 랭귀지들이 감수해야만 하는 수많은 “제약점(baggage)” (backward-compatibility requirements)을 회피했습니다. 그대신, Rust는 하이레벨(high-level language) 랭귀지의 유연성과 표현력(expressive syntax)을 받아들임과 동시에, 로레벨(low-level language) 랭귀지의 성능과 절대적인 컨트롤(unprecedented control) 능력도 융합시킬 수 있었습니다.

프로그래밍 랭귀지를 선택하는 것은 균형점을 찾는 일입니다. 대부분의 하이레벨 랭귀지는 안전한 동시성(safe concurrency)과 메모리 보호 장치(memory safety)를 제공하는 반면, 이를 위한 오버헤드를 감수합니다 (e.g. GC 사용에 따른 오버헤드). 그리고 성능이 나쁘고 미세한 컨트롤(fine-grained control) 능력이 부족합니다.

이런 한계를 극복하려면, 로레벨 랭귀지를 써야 합니다. 하이레벨 랭귀지가 제공하는 안정망 없이 로레벨 랭귀지를 쓰자면 죽기 쉽고 에러가 많은 결과물이 만들어지곤 합니다. 개발자가 메모리 관리, 자원 할당, 댕글링 포인터(dangling pointers) 문제들을 직접 다뤄야합니다. 요즘의 디바이스들이 제공하는 많은 수의 코어(core)를 충분히 활용하도록 소프트웨어를 만드는 것은 어려운 일입니다. – 코드가 정확하게 동작하도록 만드는 것은 더 어려운 일입니다.

Rust가 어떻게 하나의 랭귀지로 양쪽 세계의 장점을 통합했을까요? 그것이 본 기사에서 설명할 내용입니다. Rust 1.0.0 stable은 릴리즈된 지 얼마 되지 않습니다. 이 랭귀지는 이미 활발한 커뮤니티를 갖고 있으며, 랭귀지의 패키지 매니저를 통해 크레이트(crates) 생태계 (Rust의 라이브러리 생태계)를 키워가고 있습니다. 그리고 다양한 프로젝트에 Rust를 적용하는 많은 개발자들이 존재합니다. 당신이 로레벨 랭귀지를 전혀 접해보지 않았더라도 상관 없습니다. 지금이 Rust에 빠져 볼 최고의 순간입니다!

Rust 1.0의 전세계 릴리즈를 축하하는 Rust 티셔츠.

Rust 활용사례

시스템 해커들에게 Rust는 훌륭한 선택이라고 생각됩니다. 하지만 로레벨 랭귀지에 친숙하지 않은 사람들에게는 어떨까요? 아마도 그런 사람들은 기초 전산학 시간에 “C” 와 “스택/힙 할당(stack/heap allocation)” 에 대해 들어 본 지가 10년도 넘었을 것입니다 (어쩌면 전혀 들어보지 못했을 수도 있습니다). Rust는 통상 로레벨 시스템 랭귀지에서만 가능한 성능을 제공합니다. 하지만 대부분의 경우 Rust는 하이레벨 랭귀지처럼 느껴집니다 ! 여기 실제 어플리케이션 개발에 Rust를 어떻게 이용하는지 보여주는 활용사례가 몇개 있습니다.

하드웨어를 만들고 싶습니다/ Internet-of-Things 어플리케이션을 만들고 싶습니다

IoT 시대, 그리고 메이커 무브먼트(maker movement)의 영향으로 하드웨어 프로젝트 분야에서 진정한 참여 민주주의가 가능해졌습니다. 그것이 라즈베리파이든, 아두이노든, 아니면 비글본이나 테셀(Tessel) 같은 새로운 보드든, 당신은 파이썬과 자바스크립트 같은 많은 랭귀지들 중에서 하드웨어 프로젝트 코딩을 위한 랭귀지를 선택할 것입니다.

그러나 랭귀지가 제공하는 성능이 충분하지 못할 때가 있습니다. 또 당신이 목표로 하는 마이크로콘트롤러 하드웨어가 랭귀지 실행에 필요한 런타임을 지원하지 않을 때도 있습니다. 극히 작은 메모리와 극히 낮은 전력을 사용해야 하는 상황에서 느린 칩(chip)을 사용할 경우, 기계어에 가까운(close-to-the-metal) 언어를 선택할 수 밖에 없습니다. 전통적으로 그런 상황에서는 C 언어를 사용했습니다. 하지만 예상했을지도 모르지만 이제 Rust도 있습니다.

Rust는 무척 다양하고 특이한 플랫폼들도 지원합니다. generic ARM 하드웨어, 텍사스 인스투르먼트사의 TIVA 개발보드, 그리고 라즈베리파이까지. Rust는 실험 단계의 플랫폼들도 지원합니다. 심지어 Tessel 2 같은 최신 IoT 보드는 격이 다를 정도로 훌륭하게 Rust를 공식 지원합니다!

여러개의 코어를 모두 활용해야 하는 고성능 컴퓨터 어플리케이션을 운영하고 있습니다

많은 연구 결과들이 Rust가 이미 HPC(high-performance computing, 고성능 컴퓨팅)에 적합하다는 것을 알려주고 있습니다. 더구나 어플리케이션 전체를 Rust로 재작성할 필요도 없습니다. Rust의 유연한 FFI (Foreign Function Interface, 외부 함수 인터페이스)가 효율적인 C 바인딩을 제공하기 때문에, 당신은 Rust 코드를 별다른 오버헤드 없이 호출할 수 있습니다. FFI를 이용하면 어플리케이션의 모듈들을 점진적으로 바꿔나갈 수 있습니다. 그래서 오래된 코드와 동등하거나 우월한 성능을 내는 Rust의 개발자 경험을 점진적으로 수용할 수 있습니다. 이를 통해 여러개의 코어로 보다 잘 확장되는, 보다 유지하기 편하고 에러가 적은 코드베이스를 얻게될 것입니다.

그냥 빠른 것이 필요합니다!

Rust는 어플리케이션 중에서 성능이 중요한(performance-sensitive) 부분을 다시 작성할 때 훌륭한 선택입니다. Rust는 FFI를 통해 다른 랭귀지들과 잘 인터페이스되며, C와 C++에 견줄 만큼 매우 작은 런타임을 가지고 있어서 자원 제약이 심한 환경에서도 사용 가능합니다.

아직 개발중인 랭귀지임에도 불구하고, 이미 Rust를 이용해서 비즈니스 핵심 모듈과 상용 어플리케이션을 개발하는 사례들이 다수 존재합니다. Yehuda Katz가 만든 스타트업 회사인 Skylight는 고성능의 Rust 코드 (루비 gem 에 내장됨)를 데이터 처리(data-crunching) 분야에 사용합니다. 1.0.0 안정화 버전 릴리즈는 이제부터 스펙에 급격한 변화가 없을 것이라는 선언이기 때문에 중요한 마일스톤입니다. 이 릴리즈 덕분에 크게 중요하고 안전해야 하는 어플리케이션 개발에도 Rust를 안심하고 추천할 수 있습니다!

Yehuda Katz와 Tom Dale이 Rust 프로그래밍 기본에 대해 설명한 동영상을 보세요. 앱 개발을 위해 Rust와 Ruby를 함께 사용하는 방법에 대해 설명하고 있습니다.

Rust 시작하기

Rust에 대한 일반적인 내용을 설명하는 많은 튜토리얼들이 있습니다. 또 Rust의 특별한 측면을 설명하는 튜토리얼들도 있습니다. 예를 들어, Rust 블로그에는 Rust 어플리케이션 개발의 다양한 측면들에 대한 훌륭한 글들이 실려 있습니다. 또 Aaron Turon이 스탠포드 대학에서 강의했던 훌륭한 동영상도 있습니다. Aaron Turon은 Rust의 핵심 개념과 Rust의 개발 의도를 멋지게 설명하고 있습니다. 당신이 Rust 세계로 여행을 떠나기 전에 반드시 봐야할 동영상입니다.

동영상과 튜토리얼이 코드를 대신할 수는 없습니다, 그렇죠? Rust도 예외가 아닙니다! Rust Book은 설치 부터 첫 Hello World 프로그램 작성까지 안내합니다. 이 문서를 통해 랭귀지의 핵심 기능을 자세히 알아볼 수 있습니다.

언급할만한 또 다른 자료로 Rust by Example이 있습니다. 이 문서는 기초부터 trait, macro, FFI 같은 강력한 Rust의 핵심 기능들을 설명합니다. Rust by Example은 모든 예제 코드를 브라우저 안에서 수정하고 테스트할 수 있는 유용한 기능을 제공합니다. 모든 예제를 당신이 앉은 자리에서 바로 수정하고 테스트해볼 수 있습니다. Rust를 다운로드 하고 컴파일할 필요조차 없습니다. Rust 놀이터(Rust Playpen)도 같은 목적으로 존재합니다.

그렇다고 Rust를 다운로드하고 설치하는 것이 어려운 것도 아닙니다. Rust 홈페이지에 가면 적절한 바이너리/인스톨러를 다운로드 받을 수 있습니다. 다운로드 패키지에는 (rustc 컴파일러와 cargo 패키지 매니저처럼) 시작을 위해 필요한 모든 도구들이 모든 플랫폼 (Windows, Linux, OSX)에서 바로 실행 가능한 형태로 빌드되어 담겨 있습니다.

그런데, 무엇이 Rust를 그렇게 독특하고, 특별하게 만드는 것일까요?

Rust 방식

Rust의 확실하게 독특한 특성은 바로 오너쉽 모델(ownership model) 입니다. 오너쉽 모델은 Rust를 정말 빛나게 만듭니다. 왜냐하면 멀티 쓰레딩과 메모리 관리에 관한 모든 종류의 오류를 제거하기 때문입니다. 이 때문에 개발과 디버깅이 간단해집니다. 또 랭귀지의 런타임을 작게 유지시킬 수 있으며, 컴파일러가 가볍고 성능 좋은 결과물을 만들수 있게 하는 장점이 있습니다.

오너쉽 모델(Ownership Model)

Rust 오너쉽 모델의 기본 원칙에 따르면 모든 자원은 오직 한개의 “오너(owner)”에 소속될 수 있습니다. “자원(resource)”은 작은 메모리 조각부터 네트워크 소켓까지 또는 mutex lock 처럼 보다 추상화된 것에 이르기까지 다양합니다. 이런 자원의 오너는 자원을 사용하고, 자원을 (다른 사용 객체에게) 빌려주고, 최종적으로 해지하는 것을 책임져야 합니다.

이 모든 것은 스콥(scope)과 바인딩(binding)의 도움으로 자동적으로 이루어집니다. 자신의(own) 자원 또는 빌려온(borrow) 자원을 바인딩하면, 해당 스콥이 종료될 때까지 유지됩니다. 바인딩이 스콥을 벗어나면, 빌려온 자원일 경우 이를 반납하고 자신의 자원일 경우 이를 해지합니다.

무엇보다 좋은 점은 오너쉽 모델을 동작하게 하기 위해 필요한 검사(check)가 Rust 컴파일러와 “borrow checker”에 의해 컴파일 과정에 이루어진다는 점입니다. 이 결과 다양한 장점이 만들어집니다.

비용 없는 추상화 (Zero-cost abstractions)

프로그램의 정확한 동작이 컴파일 과정에서 보장되기 때문에, 컴파일 되는 코드는 대부분의 일상적인 메모리와 동시처리(concurrency) 에러로부터 안전합니다 (예를 들어 해지한 다음 참조하는 버그(use-after-free bugs) 또는 데이터 경합(data races) 등의 에러). 왜냐하면 Rust 프로그램을 컴파일하는 과정에서 프로그래머가 원칙을 위반하는 경우가 밝혀지기 때문입니다. 이 덕분에 랭귀지의 런타임을 작게 유지할 수 있습니다.
이런 검사를 컴파일 과정에서 처리하기 때문에, 실행(runtime) 과정에서는 이런 검사를 수행할 필요가 없습니다 (코드는 이미 “안전”합니다). 그래서 런타임 오버헤드가 전혀 없습니다. 메모리 할당(memory allocations)의 경우에도, 런타임 가비지컬렉션(garbage collection)이 필요하지 않습니다. 이렇게 진보적인 랭귀지 요소를 지원하면서도 런타임 오버헤드가 없는 것이 “비용 없는 추상화”의 기본 사상입니다.

비록 이번 기사를 통해 오너쉽 모델의 모든 것을 설명할 수는 없지만, (앞서 링크한) Rust Book을 비롯해서 많은 동영상들과 글들이 이 원칙을 잘 설명하고 있습니다. 오너쉽 원칙과 borrow checker가 Rust를 이해하는 핵심입니다. 그리고, 동시처리(concurrency)와 병령처리(parallelism) 같은 Rust 랭귀지의 강점을 가능하게 하는 기반입니다.

하나의 랭귀지로 두마리의 새 잡기

수정 가능한(mutable) 상태(state)를 공유(share) 하는 것이 모든 악의 근원입니다. 대부분의 랭귀지들은 이 문제를 수정 가능(mutable) 측면에서 해결하려고 시도합니다. 하지만 Rust는 이 문제를 공유(share) 측면에서 해결합니다.
— The Rust Book

메모리 안전성과 별개로, 병렬처리(paralellism)와 동시처리(concurrency)는 Rust 철학에 있어 두번째로 가장 중요한 관심사입니다. 놀랍게 여겨질 수도 있지만, 이번에도 오너쉽 시스템(그리고 몇가지 자잘한 기능들)이 쓰레딩 처리(threading), 동기화 처리(synchronization), 데이터 동시 접근(concurrent data access) 측면에서 강력한 도구를 제공합니다.

Rust에 내장된 동시처리 관련 기반 재료들을 깊게 파보면, 이런 기반 재료들이 랭귀지 자체의 핵심 파트가 아니라 표준 라이브러리(standard library) 형태로 제공된다는 점이 놀랍게 여겨질 것입니다. 동시처리 프로그래밍(concurrent porgramming) 방식은 랭귀지를 만드는 사람들의 결정에 따라 고착되는 부분이 아니라, 라이브러리 제작자의 몫이며, 누구나 새롭게 만들 수 있습니다.

실행성능이냐, 표현력이냐? 모두 필요!

정적 타입 시스템, 주의 깊게 선택한 기능, 가비지컬렉터를 사용하지 않는 특성 덕분에 Rust는 (C/C++ 같은) 전통적인 로레벨 랭귀지로 작성된 코드와 등등하게 성능 좋고 예측 가능한 코드를 산출해냅니다.

잡다한 검사를 런타임에 수행하지 않고, 또 가비지컬렉터를 제거함으로써, 최종 코드의 실행성능은 다른 로레벨 랭귀지에 육박합니다. 그러면서도 랭귀지 자체는 (로레벨 랭귀지) 보다 좋은 표현력을 갖추고 있습니다. (외견상) 하이레벨 랭귀지 요소들(strings, collections, higher order functions 등)은 그 처리에 있어 대부분의 런타임 성능 저하를 피하고 있습니다. Rust 컴파일러의 결과물이 LLVM 중간 표현(intermediate representation)을 따르고 있기 때문에, 최종 머신코드는 자동적으로 LLVM 컴파일러의 크로스-플랫폼 관련 장점과 함께 (현재뿐 아니라 미래에 나올) 다른 모든 최적화 기술들의 장점도 충분히 활용합니다.

Rust를 쓰면 소켓 종료나 메모리 해지에 관해 전혀 걱정할 필요가 없음에 대해, Rust의 trait와 macros가 연산자 오버로딩에 있어 엄청난 유연성을 제공함에 대해, 또는 저글링 이터레이터(juggling iterators), 클로져(closures), 하이오더 펑션(higher order function) 같은 Rust의 펑셔널 측면에 대해 더 많은 분량을 할당해서 이야기할 수도 있을 것입니다. 하지만 첫만남이 그렇게 어려울 필요는 없다고 생각합니다! 어쨌든 당신은 이런 것들을 익히게 될 것입니다. 그리고 스스로 찾아 배우는 것이 더 재미있을 것입니다.

그러니, 이제 코드를 봅시다.

Rust에게 hello라고 말하기

간단한 당신의 첫 Rust 코드입니다.

fn main() {
    println!("Hello, Rust!");
}

온라인 Rust 놀이터 (Rust Playpen) 에서 코드 열기 >>

잠깐, 이게 전부인가요? 왠지 김빠져 보일지도 모릅니다. 하지만 세상에는 Rust로 Hello World를 작성하는 아주 많은 방법이 있습니다. 더 복잡한 예제를 볼 때까지 조금만 참아주세요. 언제나 통하는 클래식한 예제들을 조금더 살펴보겠습니다.

Fizzbuzz 프로그램

옛날 학창시절로 돌아가서 FizzBuzz 프로그램을 만들어봅시다! Fizzbuzz는 끝 없이 숫자를 세어가면서 3으로 나누어 떨어지는 숫자들은 fizz로, 5로 나누어 떨어지는 숫자들은 buzz로, 3 그리고 5 모두로 나누어 떨어지는 숫자들은 fizzbuzz로 바꾸는 알고리즘입니다.

중요한 점을 드러내기 위해 (그리고 Rust 문법에 친숙해지는 것을 돕기 위해), 같은 알고리즘을 C와 Python 버전으로도 제시했습니다.

#include 

int main(void)
{
    int num;
    for(num=1; num<101; ++num)
    {
        if( num%3 == 0 && num%5 == 0 ) {
            printf("fizzbuzz\n");
        } else if( num%3 == 0) {
            printf("fizz\n");
        } else if( num%5 == 0) {
            printf("buzz\n");
        } else {
            printf("%d\n",num);
        }
    }

    return 0;
}

for num in xrange(1,101):
    if num%3 == 0 and num%5 == 0:
        print "fizzbuzz"
    elif num%3 == 0:
        print "fizz"
    elif num%5 == 0:
        print "buzz"
    else:
        print num

fn main() {
    for num in 1..101 { // 범위 표기법!
        match (num%3, num%5) { // 패턴 매칭!
            (0, 0) => println!("fizzbuzz"),
            (0, _) => println!("fizz"),
            (_, 0) => println!("buzz"),
                 _ => println!("{}", num) 
        }
    }
}

온라인 Rust 놀이터 (Rust Playpen) 에서 코드 열기 >>

이렇게 작은 코드에서도, Rust의 파워풀한 특징 몇개가 보이기 시작합니다. 가장 분명한 차이점은 아마도 전통적인 if 구문 대신 패턴 매칭을 사용한다는 점일 것입니다. if 구문을 사용하는 것도 가능합니다. 하지만 match는 러스트 개발자(Rustacean)를 위해 추가된 매우 유용한 무기입니다.

언급할만한 또 다른 사항은 for-루프 선언에 있는 범위 표기법입니다 (Python과 비슷합니다). 흥미롭게도, 이 경우 우리는 “전통적인” C-언어의 for 루프 표기법을 대신 사용할 수 없습니다. 왜냐하면 설계 개념에 따라 Rust가 지원하지 않기 때문입니다. 전통적인 for 루프 표기법은 에러를 만들기 쉽다고 여겨졌습니다. 그래서 좀 더 안전하고 유연한 반복 개념(iterable concept)으로 대치되었습니다.

fizzbuzz 예제의 패턴 매칭 구문에서 어떤 일이 일어나는지 좀 더 자세히 살펴봅시다.

...
// 패턴 매칭을 위해, 투플(tuple)을 작성합니다.
// 투플에는 정수 3 과 5 로 나눈 나머지들을 담습니다.
match (num%3, num%5) {
    // "num" 이 3 과 5 모두로 나누어 떨어지면
    // (양쪽 나머지가 모두 0 이면)
    // -> "fizzbuzz" 문자열을 출력합니다
    (0, 0) => println!("fizzbuzz"),
    // "num" 이 3 으로 나누어 떨어질 경우 (나머지가 0)
    // "num" 이 5 로도 나누어 떨어지는지? -> 신경 쓰지 않습니다
    // -> "fizz" 문자열을 출력합니다
    (0, _) => println!("fizz"),

    // "num" 이 5 로 나누어 떨어질 경우 (나머지가 0)
    // "num" 이 3 으로도 나누어 떨어지는지? -> 신경 쓰지 않습니다
    // -> "buzz" 문자열을 출력합니다
    (_, 0) => println!("buzz"),

    // 그밖의 모든 경우, 그냥 num 값을 출력합니다
    // 일러둘 것은, 매칭이 모든 경우의 수를 나타내야 한다는 점입니다
    // 즉, 가능한 모든 결과를 커버해야 합니다.
    // 이것은 컴파일러에 의해 강제됩니다!
         _ => pintln!("{}", num)
}
...

여기서는 패턴 매칭이 어떻게 동작하는지, 또는 투플이 무엇인지를 더 자세히 다루지 않을 것입니다. Rust Book, Rust Blog, 또는 Rust By Example에서 이에 관한 훌륭한 글들을 볼 수 있습니다. 하지만 이정도로도 Rust의 기능성과 가능성을 충분히 느낄 수 있다고 생각합니다.

펑셔널(functional) Fizzbuzz도 살펴볼까요?

마지막 예제를 확장시켜서 Rust의 진정한 유연성을 살펴봅시다. 두번째 예제를 통해 우리는 fizzbuzz를 좀 더 멋지게 만들 것입니다! Rust는 자기 자신을 멀티-패러다임(multi-paradigm) 랭귀지라고 정의합니다. 우리는 fizzbuzz 예제를 펑셔널 스타일로 다시 작성해 봄으로써 멀티-패러다임이 뜻하는 바를 확인해 볼 수 있습니다. 펑셔널 스타일 코드의 이해를 돕기 위해, JavaScript (ECMAScript 6 형태)로 구현한 코드도 함께 제시합니다.

Array.from(Array(100).keys()).slice(1)
    .map((num) => {
        if (num%3 === 0 && num%5 === 0) {
            return "fizzbuzz";
        } else if (num%3 === 0) {
            return "fizz";
        } else if (num%5 === 0) {
            return "buzz";
        } else {
            return num;
        }
    })
    .map(output => console.log(output));

fn main() {
    (1..101)
        .map(|num| {
            match (num%3, num%5) { // 패턴 매칭!
                (0, 0) => "fizzbuzz".to_string(),
                (0, _) => "fizz".to_string(),
                (_, 0) => "buzz".to_string(),
                     _ => format!("{}", num) 
            }
        })
        .map(|output| { println!("{}", output); output })
        .collect::<Vec<_>>();
}

온라인 Rust 놀이터 (Rust Playpen) 에서 코드 열기 >>

Rust는 클로져(closures)와 펑셔널 메소드 호출을 이용한 JavaScript의 펑셔널 스타일을 그냥 흉내내는 정도가 아닙니다. Rust는 강력한 패턴 매칭을 통해, JavaScript를 다소 능가하는 표현력(expressiveness)을 제공합니다.

Note: Rust의 반복자(iterator)는 게으른(lazy) 방식으로 동작합니다. 그래서 예제에서 처럼 .collect()를 호출해야 합니다. 이를 호출하지 않으면 위의 코드는 동작하지 않을 것입니다. 보다 자세한 내용을 알고 싶다면 Rust Book의 consumers 섹션을 확인해보세요.

프로젝트 고르기

이제 Rust 에 푹 빠져서 뭔가 멋진 것을 시작하고 싶어졌을 것입니다. 무엇을 만들 건가요? 작은 규모로 간단한 앱이나 간결한 라이브러리를 만들어서 crates.io에 업로드해보세요. 이미 많은 사람들이 Rust를 이용해서 흥미로운 프로젝트들을 많이 만들었습니다. 흥미로운 *nix 유사 커널(*nix-like-kernel)에서부터 임베디드 하드웨어 프로젝트까지, 게임에서부터 웹서버 프레임워크까지, 한계가 있다면 상상력 뿐이라는 것을 증명하고 있습니다.

만약 작게 시작하더라도, Rust 프로그래밍을 배우면서 동시에 의미 있는 기여를 하고 싶다면, GitHub에 올라와 있는 프로젝트들에 참여하는 것을 생각해보세요 (Rust 컴파일러 프로젝트도 이미 GitHub에 올라와 있는데 이 프로젝트는 Rust로 작성된 프로젝트입니다).
또는, 당신이 상용으로 개발한 앱의 일부를 Rust로 재작성해서 결과를 실험할 수도 있을 것입니다. Rust의 FFI(Foreign Function Interface)는 C 코드를 간단히 대체하는 것을 목적으로 합니다. 아주 작은 노력으로 어플리케이션의 일부를 Rust 코드로 교체할 수 있습니다. 상호운영성(interoperability)은 거기서 멈추지 않습니다. 이런 C 바인딩은 양방향으로 이루어집니다. 즉 당신은 모든 표준 C 라이브러리들을 Rust 앱에서 이용할 수도 있습니다. 또 (많은 프로그래밍 랭귀지들이 표준 C 인터페이스 라이브러리를 제공하기 때문에) Rust를 Python, Ruby, (그리고 심지어) Go 랭귀지와도 섞어 쓸 수 있습니다!

Dan Callahan의 “My Python’s a little Rust-y 동영상을 보면 Rust와 Python을 어떻게 섞어 쓰는지 알 수 있습니다.

실질적으로 Rust와 함께 사용할 수 없는 랭귀지는 없습니다. Rust를 JavaScript로 컴파일하거나 코드 안에서 인라인 어셈블리를 사용하고 싶은가요? 그럼요, 할 수 있습니다!

이제 일어나서 뭔가 멋진 것을 만들어 보세요.

잊지 마세요. Rust는 단순한 프로그래밍 랭귀지가 아닙니다. Rust는 커뮤니티입니다. 모호한 것이 있으면, 주저하지 말고 포럼이나 IRC에 도움을 요청하세요. 당신의 생각이나 작업 결과를 Rust Reddit에 공개하세요.

Rust는 이미 훌륭합니다. 그래도 Rust 사람들은 Rust를 더욱 놀랍게 만들 당신을 환영합니다!

이 글은 Szmozsánszky István이 쓴 Diving into Rust for the first time의 한국어 번역본입니다.