지금은 2023년 3월 중순이다. 4개월간 여러 회사에 입사지원하고 있었고, 4월 3일 스타트업으로 합격이 되었다.

원티드에 많은 회사에 지원을 하였다. 작년 다른 회사에 지원한 숫자 120개 정도를 제외하면 이번에는 거의 140군데의 회사에 지원한 것 같다.

최종합격 1건, 불합격 120건은 이전에 합격했던 회사이다.

이번 회사에서는 msa기반 서비스를 만드는 플랫폼 회사이며, (2021년에 창립) 이곳에서 서비스설계(기획 설계), infra(아마?), api 개발 업무를 하게 되었다.

spring(모놀리스), golang, node, rust 정도 사용하여 api 를 container as a service 로 구현하지 않을까 싶다. 관련 책들과 CNCF 를 많이 찾아보아야 한다.

현재 하는 일

현재는 msa 를 하기위해 cloud native 공부를 하고 있고 front end 부담을 덜기위한 자료찾기 + 개인연구도 하고 있다.

api 를 분산 네트워크 환경에서 구현하는 방법을 공부하며 여러 기술팀 블로그와 cncf 자료, cloud native 책을 공부한다.

이외 시간은 프론트엔드에게 api 를 전달하기위한 문서, openApi(swagger)/graphql 를 고민하고 있다..

위 문제를 고민하다가 wasm 으로 해결할 수 있지 않을까?

하면서 mdn 에서 wasm 에 대한 자료를 공부하며 개인적으로 정리하고 있다.

앞으로 할 일

rust 베이스로 wasm 을 만들어 api 를 사용하고, document 자동화를 만들어 문서기반의 의사소통을 이끌어내는 역량을 키워보고 싶다.

wasm 도 처음해보니 "api 의 dto 에 대한 validate 도 통일 할 수 있지않을까?" 하는 아이디어도 생기는데, 여러모로 책도 사서 공부하고 좋은 시간을 보내고 있다.

책 링크: http://www.yes24.com/Product/Goods/116789691

구조체는 사용자 정의 타입이다. 관련된 여러 값의 이름을 정의하고, 관련 fn 인 method 를 정의한다.

java나 javascript 의 class 와 비슷하다.

struct User {
    active: bool,
    username: String,
    email: String,
    sign_in_count: u64,
}

User 라는 타입을 만들고

fn main() {
    let user1 = User {
        active: true,
        username: String::from("someusername123"),
        email: String::from("someone@example.com"),
        sign_in_count: 1,
    };
}

사용한다.

rust 핵심 소유권을 간단하게 알아보자.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;

    println!("{}, world!", s1);
}

이 코드를 실행하면 에러가 발생한다.

3번째 라인, let s2 = s1; 에서 발생한 오류인데, value 가 이미 이동(move) 했다는 메시지다. s1 는 소유권이 이동되었고, 사용할 수 없다는 뜻이다.

소유권 규칙

Rust 는 아래 규칙을 가진다.

1. rust 의 각 value 는 소유자가 있다.
2. 한 번에 한 명의 소유자만 있다.
3. 소유자가 범위를 벗어나면 값이 삭제된다.

따라서

{
    let s = "hello"; // s 는 소유권을 가진다.
}
// 여기서 위 스코프의 s 값은 삭제되어있다.(deleted)

위처럼 변수 s 는 보이지 않지만 소유권을 가지고 있다.

{
    let A = 10; // A 는 소유권을 가진다.
    let B = A; // A의 소유권을 B가 가지며, A는 참조할 수 없게된다.
}
// 여기서 위 스코프의 A, B 값은 삭제되어있다.(deleted)

이동(move)

rust 에서 소유권을 주는 행위를 'move'라고 표현한다.

let A = 10;
let B = A; // A의 소유권 이동

위의 표현을 아래처럼 해석한다.

A 에 10 리터럴을 할당하고 소유권을 부여한다.
B 에 A를 할당하며, A의 소유권을 이동시킨다.

이동된(moved) 변수는 더 이상 사용할 수 없다. 변수 A를 다시 사용할때, Rust 가 참조를 사용하지 못하게 한다.

소유권 규칙 2번이 적용된다. (한 번에 한 명의 소유자만 있다.) A는 소유권을 잃게되며 동시에 B가 소유권을 가진다.

위 개념은 간단한 설명이며 오해할 수 있다. rust 로 무언가를 하려면 깊게 알고 있어야 좋다.

이를 이해하기 위해서 문서를 직접 읽어보고 직접 타이핑해보자.

https://doc.rust-lang.org/beta/book/ch04-01-what-is-ownership.html#what-is-ownership

참조(references)

기존 변수의 소유권을 주지 않고 값 만 '참조'하는 방법이다.

&를 사용해보자.

fn main() {
    let s1 = String::from("hello");
    let s2 = &s1;

    println!("{}, world!", s1);
}

위 코드는 실행해도 에러없이 결과가 나온다.

s1 변수의 '값'을 '참조'만 시켜서 '소유권'을 이동시키지 않는다.

참조 또한 규칙이 있으며,

let mut s = String::from("hello");
let r = &mut s;
...

위처럼 mut 변수로써 참조 할 수 있다. https://doc.rust-lang.org/beta/book/ch04-02-references-and-borrowing.html#mutable-references

소유권,참조 규칙과 에 의하여 댕글링 포인터 문제를 예방한다.

https://doc.rust-lang.org/beta/book/ch04-03-slices.html 위 문서를 통해 참조로 구성된 collection 인 slice 를 공부하자.

제어문 if

https://doc.rust-lang.org/beta/book/ch03-05-control-flow.html#if-expressions

if 조건 {
} else if 조건 {
} else {
}

위 형태와 같다.

아래 특징이 있다.

• 조건에서 ()같은 괄호가 필요없다.(필요할 때만 넣어주면 된다.)
• bool 명시를 해줘야한다.

fn main() {
    let condition = true;
    let number = if condition { 5 } else { 6 };

    println!("The value of number is: {number}");
}

이렇게 if 로 변수를 할당 가능하다.(삼항연산자 느낌이다.)

반복문 loop, while, for

https://doc.rust-lang.org/beta/book/ch03-05-control-flow.html#repetition-with-loops

다른 언어와 크게 다른게 없다. 생략한다.

fn main() {
    for number in (1..4).rev() {
        println!("{number}!");
    }
    println!("LIFTOFF!!!");
}

1부터 4미만의 수를 배열로 만든다. 해당 배열은 rev 는 reverse 약자로 해당 배열 순서를 역전한다. 이후 각 요소가 number 로 할당되며 반복된다.

문서볼때 이 친구가 있으면 컴파일 안되는게 정상이다. 문서를 읽다보면 가장 많이 보이는 이미지다.*(1) (https://doc.rust-lang.org/beta/book/ch00-00-introduction.html#ferris)

이 친구가 없는데도 컴파일이 안된다면 사용하던 lib 버전이 달라지며 생긴 문제다.

변수 사용법 (변수와 가변성)

따라해보자

"Cannot ... variable" 는 변경 할 수 없는 변수에 2번째로 값을 할당 할 수 없다는 뜻이다.

fn main() {
    let mut x = 5;
    println!("The value of x is: {x}");
    x = 6;
    println!("The value of x is: {x}");
}

let x = 5; 에서 let 뒤에 mut 를 넣으면 변수가 mutable(가변) 이 된다.

rust 가 사용하는 변수는 default 로 immutable(불변)이라는 점을 알 수 있다.

Fp 스럽지 않은가?

Shadowing (그림자)

https://doc.rust-lang.org/beta/book/ch03-01-variables-and-mutability.html#shadowing

fn main() {
    let x = 5;

    let x = x + 1; // let x = 5; 가 가려지고 새로운 x 는 6이 된다.

    {
        let x = x * 2; // 위와 같은 개념으로 6 * 2 값을 가진 x 가 {} 안에서 할당된다.
        println!("The value of x in the inner scope is: {x}");
    }
    // 바로 위의 {} 를 벗어나며 x 는 기존 6 으로 존재한다.
    println!("The value of x is: {x}");
}

// 결과
// The value of x in the inner scope is: 12
// The value of x is: 6

섀도잉은 {} 범위 내에서 같은 이름의 변수를 만들며 기존 변수를 감춘다. mut 를 굳이 안써도 되는 상황에 대체하기 좋은 방법이다.

mut 를 반드시 써야할때는

• 변수가 fn 를 통해 변경되어야 함
• 반복문을 통해 변수가 만들어진 후, 변경되어야함.

정도 되지 않을까?*(2)

위 경우에도 섀도잉으로 짤 수는 있지만 가독성을 위해 mut 를 쓸 경우도 있어보인다.

데이터 타입

https://doc.rust-lang.org/beta/book/ch03-02-data-types.html#data-types

Rust 언어는 정적인 구조("동적"의 반대)가 빠르다. 이는 데이터 타입도 정적일때 빠르다는 것을 말한다.

하지만 변수의 데이터 타입이 동적으로 할당되는 경우가 필요할 수 있다. (입력 받은 string 배열 개수는 예측하지 않고 싶은 경우 등)

이런 경우, run-time 중에 메모리를 할당해야 하므로 정적인 구조(예측 가능한 수의 할당) 보다 느릴 수 밖에 없다.

개발자는 여러 요인을 생각하며 mut 나 동적 타입을 도입해야한다.

Functions

https://doc.rust-lang.org/beta/book/ch03-03-how-functions-work.html#functions

함수는 작성하기 쉽다.

// 반환 없음
fn 함수이름(파라미터이름: 타입) {
    ...;
}
// 반환 있음
fn 함수이름(파라미터이름: 타입) -> 리턴타입 {
    ...;
    리턴변수    // 세미콜론이 없다.
}

위 형태다.

세미콜론이 없는 마지막 라인은 반환할 변수이다.

fn main() {
    let x = plus_one(5);

    println!("The value of x is: {x}");
}

fn plus_one(x: i32) -> i32 {
    x + 1    // 여기 뒤에 ; 붙이고 실행하면 i32를 return 안했다고 error 가 뜬다.
}

실행해보면 잘 나온다.

주석

주석을 이미 보여줬는데. 해당 line 뒤에 // 를 붙이면 된다.

*(1) rust 는 다른 언어보다 error 가 발생할 경우가 많다. *(2) 진짜 추측이다. 정확히 모른다.

cargo 는 rust 에서 사용하는 패키지 매니저다. javascript 의 npm, yarn 같은 포지션이다.

rust 에서 사용할 library 의 dependency, 패키지의 메타정보(이름, 버전 등)을 관리한다.

[package]
name = "hello_cargo"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]

Cargo.toml 은 위 형태다. toml 포맷 참조: https://toml.io/ko/v1.0.0

cargo new
cargo check
cargo build
cargo run

위처럼 프로젝트를 만들고(new), 빌드하며(build), 빠르게 빌드없이 에러만 체크하고(check), 빌드 후, 추가로 바로 실행한다(run).

여기서 기본 빌드는 빠른 컴파일을 수행한다. 컴파일이 빠르면, 빌드를 빠르게 테스트 해볼 수 있지만 배포시, 최적화가 없다.

cargo build --release

위처럼 build 를 하면 컴파일은 느리지만 최적화가 진행되어 가볍고 빨라진다.

hello world 를 해보자.

필자는 mac m1 을 쓰고 있다.

toolchain 은 해당 언어의 개발툴 /bin 위치다. 아마 clion 설치하자마자 New Project 에 Rust 가 없을텐데,

Plugins 에서 설치하면 된다.

이런 구조다.

hello world 가 자동으로 만들어졌다. 자동으로 안만들어지면 docs 를 따라하자. (https://doc.rust-lang.org/beta/book/ch01-02-hello-world.html#creating-a-project-directory)

option + F12 키를 누르고, 터미널을 띄운 후 명령어를 사용한다.

cargo run

clion 을 통해 rust binary 프로젝트를 만들고 [ Hello, world! ] 를 출력하였다.

이 시리즈는 위 사이트를 참고하여 공부한다.

공부 순서는 이론 -> 문법 순서로 진행된다.

문서가 잘 되어 있어서 굳이 블로그들을 찾아볼 필요가 없다. 이 글도 마찬가지

23년 3월 기준으로 21 chapter 까지 있다.

3 chapter 까지 간단한 문법이 진행되는데, FP(Functional Programming) 컨셉을 가져왔다 카더라. 힙하다.

4 chap 에서 소유권(ownership) 을 말하고 있는데, 현 시점(2023.3)에 이런 패턴을 강제하는 언어는 유일하다. 소유권 개념이 메모리 문제나 동시성에서 발생하는 문제 등을 해결한다.

다른 언어에서 '할당'은 gc 를 쓰냐 안쓰냐에 따라 '해제(malloc)' 를 쓰냐 안쓰냐로 갈리는데, rust 는 gc가 없고 해제도 안보인다.

5 chap 에서 struct 와 traits 를 맛보기 한다. rs 에서 사용하는 자료구조이다. struct 는 class, traits 는 interface 정도로 느껴진다.

이후 챕터부터 본격적으로 진행하며, 중간중간 작은 프로젝트가 껴있다.