Rust를 배우고 사용하며 열거형, 타입 주도 개발, 소유권, 아레나, 성능에 대한 관점이 어떻게 바뀌었는지 돌아봅니다.
사용하는 프로그래밍 언어는 소프트웨어 개발자로서 사고하는 방식에 영향을 미친다 1. 놀랍게 들릴 수도 있다. Python을 알고 있어서 JavaScript를 꽤 빨리 익혔고, 그것이 사고방식이나 개발 방식에 실제로 영향을 주지는 않았을 수도 있다. 그 언어들은 꽤 비슷하기 때문이다. 프로그래밍 언어가 익숙한 것과 더 다를수록, 당신을 더 많이 바꿀 수 있다. Rust는 내게 상당히 달랐고, 그래서 나를 바꾸었다.
나는 Rust로 6년 넘게 개발해 왔으며, 그중 4년 이상은 전문적으로현재까지 개발했다. Rust에 정말로 더 능숙해지고 싶었던 이유 중 하나는, 이것이 나에게 도전이 되고 바라건대 개발자로서 더 나은 방향으로 바꿔 줄 것임을 알았기 때문이다. 실제로 그랬다고 생각한다.
내가 배웠고 여기서 이야기하려는 내용은 Rust에만 국한되지 않는다. 이러한 개념 다수는 다른 맥락에서도 접할 수 있고, 실제로 나는 이미 꽤 많이 접했었다. 하지만 이 경우 Rust는 그 개념들을 더 선명하게 부각하는 데 도움을 주었다.
우리는 모두 곱 타입에 익숙하지만, 보통 그 이름으로 부르지는 않는다.
struct Human {
first_name: String,
last_name: String,
}
Human 구조체 2의 필드는 서로 독립적으로 달라질 수 있으며, 가능한 모든 조합, 즉 가능한 모든 이름과 성의 결합을 다뤄야 한다. 말하자면 조합의 _곱_이다.
하지만 영원히 존재해 왔으면서도 프로그래밍 공동체가 대체로 무시해 온 3 또 다른 타입 개념이 있다. 바로 합 타입이다. 합 타입은 여러 변형 중 하나이거나 다른 하나인 변형을 표현한다.
enum Person {
Human { first_name: String, last_name: String },
Cat { name: String, cuteness: Cuteness }
}
Person은 인간이거나 고양이다. 이것이 가능성의 _합_이다. 각 변형에는 연관된 데이터가 있을 수 있고, 그것은 곱 타입일 수 있지만 Person 타입 자체는 이 선택지들뿐이다(여기서는 두 가지다). 사람을 다뤄야 하는 코드에서는 객체에 대해 match를 사용해 각 변형을 처리해야 한다. Rust 컴파일러가 이를 강제한다.
match some_person {
Human { first_name, last_name } => {
// do a thing with first_name and last_name
},
Cat { name, cuteness } => {
// do a thing with name and cutenes
}
}
인간 변형을 처리할 때는 first_name과 last_name만 신경 쓰면 된다. name이나 cuteness는 전혀 신경 쓸 필요가 없다. 이 경우들은 서로 구별된다.
합 타입을 사용해 대상을 모델링하는 일은 매우 유용한 것으로 드러난다. 함수형 프로그래밍 언어를 쓰던 사람들은 이미 이를 알고 있었다. 선택성(null)도 이런 방식으로 모델링할 수 있다. 값이 있거나, 아무것도 없는 것이다. 오류도 모델링할 수 있다. 성공한 경우의 반환값과 함께 정상 상태이거나, 오류를 설명하는 값을 지닌 오류 상태다.
이제 합 타입이 없는 언어는 내게 빈곤하게 느껴진다. 어떤 타입 필드로 이를 흉내 낼 수 있다는 것은 알지만, 프로그래밍 언어의 역할은 기본적인 일을 처리하도록 돕는 것이며, 이것은 기본적인 일이다.
객체 지향 프로그래밍 언어에서는 동적 디스패치와 인터페이스(또는 상속)를 사용해 변형을 처리한다. 다음과 같이 한다.
interface Person {
def do_one_thing()
def do_another_thing
}
class Human implements Person {
...
}
class Cat implements Person {
...
}
이제 내부 세부 사항을 걱정하지 않고 어디서나 Person을 사용할 수 있다는 발상이다. 느슨하게 결합되어 있으며, 그 인터페이스만 사용한다.
이는 정말 훌륭한 발상이지만, Rust는 이것이 내가 치르고 싶지 않을 수도 있는 대가를 수반한다는 점을 가르쳐 주었다. 두 가지 대가가 있다. 성능과 인터페이스를 만들어야 한다는 점이다.
인터페이스를 만들어야 하는 필요성부터 이야기해 보자. 애플리케이션에 실제로 의미가 있는 인터페이스를 고안해야 한다. 즉, 모든 곳에서 인간과 고양이를 어떻게 사용하고 있는가? 이러한 추상화 작업은, 특히 나중에 이를 사용하는 코드를 수정하지 않고도 연결할 수 있는 알 수 없는 미래의 사람들을 예상한다면, 매우 가치 있을 수 있다. 코드가 개방-폐쇄 원칙을 따르기를 원할 것이다.
하지만 단일 도메인을 개발하고 있으며 그 안에서 고양이와 인간을 처리하기만 하면 된다면 어떨까? 다른 유형의 사람을 연결할 필요가 전혀 없고, 특히 외부에서 연결할 필요는 없다.
혹은 가끔 새 변형을 하나 추가하고 싶다고 하자. Dog를 추가하고 싶을 수 있다. Human과 Cat을 처리하는 코드를 살펴보고 개 처리도 추가하는 것이 실제로 괜찮을 수 있다. 그렇게 할 때 다른 처리기들도 바로 거기서 볼 수 있는 편이 오히려 도움이 될 수 있다. 컴파일러는 빠뜨린 곳이 없도록 보장해 줄 것이다!
또는 고안하려는 추상화 자체가 _변형성_이며, 그것에 대해 말할 수 있는 것이 대체로 그것뿐이라면 어떨까? 오류 처리에서 추상화는 어떤 값과 함께 정상 상태이거나, 어떤 오류 값인 것이다.
이 경우 가치가 없음에도 인터페이스를 만드는 대가를 치르고 있을 수 있다.
enum이 실제로 필요한 전부일 수 있다. 절차가 적고, 정적으로 검사된다. 마지막으로, 열거형이 그러한 추상화를 만드는 것을 막지는 않는다는 점도 언급하겠다. 구조체에 하듯 열거형에도 메서드를 추가할 수 있다.
열거형은 내 정신적 도구 상자에 추상화를 위한 또 하나의 기초적이고 단순하며 이해하기 쉬운 언어 구문을 더해 주었기에 나를 더 나은 프로그래머로 만들었다.
많은 언어에는 두 종류의 디스패치가 있다. Person 인터페이스 사례에서 논의한 동적 디스패치와, 다음과 같은 조건부 디스패치다.
if something {
do_this_thing()
} else
do_another()
}
Rust에는 요청하면 동적 디스패치가 있다. 또한 앞서 논의한 조건부 디스패치의 강화된 형태, 즉 열거형에 대한 매치도 있다. 조건부 디스패치도 있다. 그것은 그저 [특수한 경우][https://docs.rs/bool/latest/bool/enum.Boolean.html]다.
Rust가 생각하게 만드는 또 다른 종류의 디스패치가 있다. 정적으로 컴파일되는 디스패치다.
인간 집단 또는 고양이 집단을 다루며, 그들에게 몇 가지 연산을 수행하고 싶다고 하자. 그 연산에는 공통 동작이 있다(예를 들어 수를 세고 싶다). 집단 또는 컬렉션은 각 항목이 특정 기본 속성을 충족하기만 하면, 무엇이 들어 있는지는 실제로 신경 쓰지 않는다.
Person 열거형을 만들 수 있다. 여러 구현을 가진 열거형 또는 인터페이스를 만들고, 각 항목이 인간인지 고양이인지에 따라 실행 시간에 집단의 모든 구성원에게 디스패치할 수 있다. 하지만 이는 실제로 존재하지 않는다고 방금 말한 인간과 고양이가 섞인 집단까지 고려해야 함을 뜻한다.
대신 Rust에서는 이를 다르게 표현할 수 있다. 여전히 Person 인터페이스(트레이트)가 있지만, 개별 Person 타입(Human 또는 Cat)을 컴파일 시간에 구성한다.
struct Group<T> {
// some fields
}
// compile time assembly,
// then runtime creation of the assembled group of cats
let cat_group: Group<Cat> = Group::new();
이제 집단의 항목에 고양이가 아닌 연산을 사용하면 Rust는 컴파일을 거부한다. 이는 더 이상 신경 쓸 필요가 없는 불변 조건이다. TypeScript나 Python 같은 다른 언어의 제네릭으로도 익숙할 것이다.
Rust에서 고양이 집단을 처리할 때는, 프로그램이 실행되기도 전에 모두 고양이임을 이미 알고 있으므로, 각 항목이 인간인지 고양이인지 검사하는 지점 자체가 없다. Rust는 고양이 코드로 직접 디스패치하며 인간 코드는 작동하지 않는다. 각 집단 구성원에 대한 간접 디스패치를 피하게 되며, 성능이 중요한 상황에서는 이것이 중요할 수 있다.
Rust는 디스패치와 성능의 연결을 더 잘 이해하게 해주었기에 나를 더 나은 프로그래머로 만들었다.
1990년대 후반에 C++에서 Python으로 넘어와 Python을 발견했을 때, 동적 타이핑은 계시였다. 아주 적은 절차로 많은 일을 할 수 있었다. 지난 10년 정도 나는 타입(훨씬 더 인체공학적인 타입)과 더 많은 절차로 돌아가는 길고 굽이진 길을 걸어왔다. 많은 사람이 나와 함께 이 여정을 해왔다고 느낀다 4.
타입은 코드가 실행되기 전에 정적으로 검사할 수 있다. Rust에서는 컴파일러가 결과물을 정말 고성능의 코드로 컴파일하도록 도울 수도 있다. 둘 다 훌륭하다. 하지만 타입에는 더 미묘한 이점도 있다. 비유를 통해 이야기해 보겠다.
왜 자동화 테스트를 만드는가?
명백한 이유: 자동화 테스트는 코드의 다양한 속성이 작동하고 계속 작동하도록 보장한다.
미묘한 이유: 테스트를 작성하면 구현 중인 아키텍처와 API를 더 신중하게 생각하게 된다. 코드를 테스트 가능하게 만드는 일은 더 나은 아키텍처로 이어질 수 있다. 이것이 테스트 주도 개발의 통찰이다.
왜 문서를 작성하는가?
명백한 이유: 사람들(그리고 이제는 기계도)은 문서를 읽어 소프트웨어의 이유와 기능을 5 이해할 수 있다.
미묘한 이유: 문서를 작성하는 행위는 소프트웨어의 아키텍처와 API를 생각하게 할 수 있다. 그것에 대해 쓸 수 없다면, 아직 제대로 만들지 못한 것 아닐까? 이것이 문서 주도 개발이다.
왜 타입을 작성하는가?
명백한 이유: 코드가 실행되기 전에 정적으로 검사한다! 실행 시간 오류를 방지한다! 성능!
미묘한 이유: 타입을 이용해 도메인 모델이 일관되게 맞물리도록 모델링한다. 열거형은 여기에서 정말 가치 있다. 열거형으로 검증하지 말고 파싱하라를 표현한다. 타입은 소프트웨어의 아키텍처와 API를 이끈다.
이것은 사람들이 모든 테스트, 모든 문서 또는 모든 타입을 미리 작성한 다음 구현하는 대규모 선행 설계 과정처럼 들릴 수 있다. 6 내가 말하는 것은 그것이 아니다. 배워 가면서 테스트, 문서, 타입으로 계속 돌아가는 반복적 개발을 이야기하는 것이다.
Rust는 타입이 개발하는 동안 생각하도록 돕는 또 하나의 도구임을 선명하게 보여 주었다.
Rust는 타입 주도 개발을 온전히 받아들이게 해주었기에 나를 더 나은 프로그래머로 만들었다.
Rust를 접하며 겪은 가장 큰 놀라움은 다음과 같다. Python처럼 풍부한 런타임을 갖춘 동적 인터프리터 언어와 연관 지었던 동작 대부분을, Rust에서는 매크로를 사용해 정적으로 실제 구현할 수 있다.
마법에 관해 이야기해 보자.
Python 객체의 상태를 덤프하고 싶다고 하자. 모든 필드를 검사하고, 타입을 살펴보고, 각각을 문자열로 바꾼 다음, 모든 문자열을 하나의 큰 문자열로 합친다. 이제 어딘가에 저장할 수 있다. 나중에 그 문자열을 다시 객체로 복원한다. 어떤 객체든 저장하고 불러올 수 있다. 마법이다! Python은 이를 pickle이라고 부른다.
JSON으로 직렬화해야 한다면 어떨까? Python에는 타입 시스템이 있으며, Pydantic 같은 라이브러리는 실행 시간에 타입 객체를 검사한 뒤 이 정보를 이용해 Python 객체를 JSON으로 자동 직렬화하거나, 다시 Python으로 파싱하게 해 준다. 더 많은 마법이다!
Rust는 컴파일 언어다. 타입은 실행 시간 객체가 아니다. 리플렉션 없이는, 그리고 리플렉션에는 특별한 노력이 필요하기에, Rust에서 타입의 실행 시간 인트로스펙션은 할 수 있는 일이 아니다.
하지만 Rust는 Pickle과 Pydantic이 하는 일을 여전히 컴파일 시간에 할 수 있다.
pickle과 Pydantic에 대한 Rust의 답인 serde에서는 일반 Rust 타입을 사용하고 몇 가지 선언을 부여하면, 이를 JSON이나 toml 설정 형식, 기타 여러 형식으로 직렬화하고 다시 불러올 수 있다. 어노테이션은 다음과 같다.
#[derive(Serialize, Deserialize)]
struct Human {
first_name: String,
last_name: String
}
clap에서는 예상하는 명령줄 인자를 정확히 표현하는 타입을 만들고(enum도 사용한다!), Rust에서 일반적으로 API를 문서화하는 방식으로 문서화하면, 곧바로 내장 도움말을 갖춘 CLI가 생긴다. 다양한 경우를 처리하는 코드는 잘 타입화된 데이터를 받는다. 그 시점에는 CLI를 표현하는 데 사용한 바로 그 타입을 이용해 이미 올바르게 파싱되었다.
다음과 같다.
/// My first CLI
#[derive(Parser)]
struct MyFirstCli {
/// How many cats do you want?
#[arg(long, short)]
amount_of_cats: usize
}
다시 선언적인 #[] 구문이 등장한다. Python의 데코레이터와 매우 비슷해 보인다. 그러나 Python 데코레이터는 실행 시간에 실행되며, Rust는 보통 그렇게 할 수 없다고 방금 말했다.
Rust에서는 어떻게 가능한가? 매크로다! 매크로를 사용하면 컴파일 시간에 코드를 생성하는 코드를 작성할 수 있다. serde에서는 매크로가 어노테이션이 붙은 타입을 위한 방대한 직렬화 코드와 역직렬화 코드를 생성한다. 이 생성된 코드는 나머지 코드와 함께 컴파일된다. 컴파일러는 다른 코드와 마찬가지로 이를 최적화할 수 있다.
코드 생성은 무섭다. 매크로도 무섭다. 동적 타입 언어에서 인트로스펙션을 수행하는 일은 코드가 파싱되고 생성되는 Rust 매크로를 사용하는 것보다 훨씬 쉽다. 매크로는 애플리케이션 코드와 무작위로 섞여서는 안 된다. 매크로는 프레임워크에 속한다. 그렇다고 쉬운 것이 가볍게 사용되어야 한다는 뜻은 아니다. Python에서도 일반적으로 선언적 프레임워크 안에 마법을 신중하게 캡슐화하고 싶을 것이다.
Rust는 새로운 종류의 프레임워크 패턴을 배우게 해주었기에 나를 더 나은 프로그래머로 만들었다.
Rust는 가비지 컬렉터를 사용하지 않으면서도 메모리 누수 없는 코드를 작성하게 해주는 것으로 유명하다. 또한 다른 곳에서 읽고 있는 데이터를 변경하지 못하게 하여, 특히 병렬로 실행되는 코드에서 이상한 미정의 동작의 온갖 부류에 빠지는 일을 불가능하게 만든다.
Rust의 소유권 시스템은 Rust 학습을 어렵게 만드는 핵심 요소 중 하나다. Python, JavaScript, Java 및 많은 다른 언어에는 가변 참조가 어디에나 있으며, 순환 데이터 구조도 그냥 만들 수 있다. Rust는 기본적으로 어느 쪽도 허용하지 않는다.
다음에 해당하는 코드는 Rust에서 컴파일되지 않는다.
class Item:
def __init__(self, value):
self.value = value
class Container:
def __init__(self, items):
self.items = items
my_item = Item()
my_container = Container()
my_container.items.append(my_item)
my_item.value = "I change you!"
이 역시 컴파일되지 않는다.
class Node:
def __init__(self, parent, value):
self.parent = parent
self.value = value
self.children = []
def add_child(self, node):
node.parent = self
self.children.append(node)
Rust는 순환 참조를 그냥 허용하지 않는다. 이 경우에는 자식 및 부모 참조를 모두 갖는다.
처음에는 매우 제한적으로 느껴진다! 대신 무엇을 하는가? 대상을 변경하려면 변경(흔히 생성 중에 일어난다)과 데이터 사용을 분리하는 방법을 배운다. 이는 많은 맥락에서 좋은 일이다. 불변 조건이 적을수록 추론하기 쉬워지지만, Rust가 이를 엄격하게 강제하는 데에는 약간 익숙해져야 한다.
순환 참조는 더 까다롭다. 다음에 아레나를 논의할 때 다루겠다.
이상한 일이 일어난다. 이 마찰을 받아들이면 코드베이스의 아키텍처가 개선될 수 있다. 코드는 덜 결합된다. 코드를 이해하고 테스트하고 디버그하기 어렵게 만드는, 멀리 떨어진 곳에 영향을 미치는 이상한 뒷길을 만들기 어렵다 7.
Rust 코드는 국소적으로는 이해하기 어려울 수 있다. 하지만 더 큰 코드베이스에서 데이터가 어떻게 흐르고 무엇이 무엇을 하는지는 대체로 더 깔끔해진다.
Rust는 소유권에 대해 더 신중하게 생각하게 했고, 이것이 아키텍처에 긍정적인 영향을 주었기에 나를 더 나은 프로그래머로 만들었다.
몇 년 전 Rust의 여러 XML 트리 라이브러리를 분석했다. 내가 찾은 최고는 roxmltrree였고, 불변 트리를 제공했다. 하지만 나는 가변 트리가 필요했다. 가변성을 지원하는 라이브러리를 꽤 많이 찾았지만, 다수는 부모 참조를 지원하지 않았다. 노드의 조상 체인을 위로 탐색할 수 없었다. 일부 XML 기능 지원의 부재와 더불어 이것이 내가 Xot 형태로 직접 만든 이유다.
부모 참조가 놀랍도록 부족한 이유는 앞서 논의한 소유권 제약이다. Rust는 순환 참조를 어렵게 만든다. 참조 카운트 타입과 내부 가변성을 사용하면 이를 우회할 수 있지만, 많은 경우 이 패턴은 실제로 최적이 아니다. 장황하고 성능도 낮으며 참조 카운트 순환은 메모리 누수 위험이 있다. 대신 노드를 배열에 저장하고 배열 인덱스를 참조로 사용한다. 그러면 부모를 참조하는 인덱스와 자식을 참조하는 인덱스, 또는 다른 모든 순환 참조를 가질 수 있다.
이 패턴의 멋진 이름은 ‘아레나’이며, Rust에서는 어디에나 등장한다.
아레나에서는 많은 객체를 같은 메모리 영역(배열)에 함께 저장한다. 이것으로 무엇을 할 수 있을까?
내용물을 빠르게 순회할 수 있다. 객체가 같은 메모리 영역에 있으면 CPU가 캐시를 효과적으로 사용할 수 있다. 이는 임의의 주 메모리 접근보다 훨씬 빠르며, 루프는 특히 이점을 얻는다.
빠른 할당. 아레나는 블록으로 힙에서 할당되며, 그 후 할당은 몇 번의 증가 연산에 불과할 수 있다.
인터닝: 아레나에 무언가를 한 번 저장하고 여러 곳에서 사용하므로 데이터를 복제하지 않는다.
아레나는 그 안의 대상을 소유한다. 아레나 안의 모든 것은 같은 수명을 갖는다. 아레나 내 객체 간 인덱스는 걱정 없이 순환할 수 있다.
Rust는 아레나를 사용하도록 이끈다. 이는 직접 참조를 사용하는 것보다 더 많은 절차를 수반하지만, 컴퓨터가 매우 효율적으로 실행할 수 있는 코드를 작성하도록 Rust가 이끈다는 의미이기도 하다.
성능을 여러 차례 언급했다. 하지만 성급한 최적화는 어떨까? 이 인용문의 커다란 아이러니는 저자인 Knuth가 효율적인 소프트웨어를 작성하는 데 필수적이므로 goto 문을 유지해야 한다고 주장하는 글에서 나온 말이라는 점이다.
Rust는 무엇에 대가를 치르는지 알 수 있게 한다. 참조 카운팅? 동적 디스패치? 할 수는 있지만 코드에 드러난다. Rust는 또한 언제 그 대가를 치르고 싶지 않은지 알 수 있게 해준다. tower 미들웨어를 보고 비교적 단순한 추상화 위에 쌓이는 모든 제네릭 타입과 타입 제약에 절망하면 된다.
이러한 도구를 쓸 수 있게 되면, 전에는 중요해 보이지 않았던 절충에 관한 새로운 지혜를 길러야 한다. Python 코드를 작성한다면 해시 테이블이 성능 병목이라는 점을 크게 걱정하지 않지만, Rust 코드에서는 분명 그럴 수 있다. 가는 길에 초최적화의 땅에서 길을 잃을 수 있다. 흔히는 그냥 계속 나아가야 한다 8. 어차피 단순히 읽기 좋은 Rust 코드인 많은 패턴은 우연히도 그것을 실행하는 CPU에 친화적이다.
하지만 Rust가 생각하고 싶지 않은 세부 사항으로 당신을 압도한다는 것이 이야기의 전부는 아니다. 성능은 단지 양적인 것이 아니기 때문이다. 코드가 진정으로 더 높은 성능을 낼 수 있다면, 새로운 특성에 접근할 수 있다. 메모리와 CPU 시간을 전혀 쓰지 않는 코드를 작성할 수 있다면 9, 사고방식이 바뀐다. 가능한 것이 바뀐다.
때로 성능의 특성은 명백하다. 수치 코드나 시뮬레이션을 작성한다면, 당연히 답을 기다리고 싶지 않을 것이다. 매우 많은 계산을 정말 빠르게 수행할 수 있는 능력은 AI를 가능하게 하는 핵심이다.
하지만 그보다 더 미묘하다. 현대 컴퓨터는 정말로 강력하고 터무니없이 빠르지만, 우리는 대체로 이를 무시하고 문제에 더 많은 자원을 투입한다. 여기에는 그럴 만한 이유가 있다. 하지만 눈을 조금만 뜨면 탐색할 새로운 아키텍처 가능성이 있다.
매크로의 힘이 가장 큰 언어적 놀라움이었다면, 이것이 내 사고에서 가장 큰 변화라고 생각한다. 성능에 접근하면 전에는 고려하지 않았던 가능성이 열린다. 내 실험 Colchis를 보자. 라이브러리는 막대한 양의 JSON을 메모리에 저장하면서 JSON 데이터에 대한 완전한 접근, 심지어 인덱스 접근까지 유지할 수 있다(언젠가 jsonpath도 추가하고 싶다!). Rust 이전에는 이것은 내 관심 범위에도 없던 가능성이었다.
Rust는 컴퓨터가 더 적은 것으로 더 많은 일을 하게 만들 수 있게 해주었고, 새로운 기회의 영역을 열어 주었기에 나를 더 나은 프로그래머로 만들었다.
Rust는 내가 배운 프로그래밍 언어 중 가장 어려운 언어 중 하나이며, 따라서 나를 가장 많이 바꾼 언어 중 하나다. 다른 어떤 언어보다 관리하기 훨씬 어렵지 않고, 경우에 따라 실제로 삶을 더 쉽게 만들 수도 있는 Rust의 단순한 부분이 있다. enum, 선언적 타입 주도 프레임워크, 뛰어난 개발 도구가 떠오른다. 아레나조차 근본적으로 이해하기 그리 어렵지 않다. 복잡성은 몇몇 습관을 버리고 새 습관을 배우는 데 있다. 그리고 필요할 때 거기에 있는, 주로는 표면 아래에 있지만 항상 그렇지는 않은 더 도전적이고 복잡한 Rust가 있다.
Rust는 내가 만들 수 있는 것의 범위를 넓힌다. 그것이 내가 이 여정을 떠난 것을 기쁘게 만드는 이유다. 10
1
AI 에이전트는 많은 코드를 작성한다. 그들은 프로그래밍 언어를 안다. 그렇다면 당신도 알아야 할까? 언어는 여전히 개발자에게 영향을 미칠까? 나처럼 코드를 살펴보는 것이 좋다고 믿는다면, 읽는 코드를 이해하는 것이 도움이 된다. 또한 사용하는 시스템이 사고와 행동 방식에 어떤 영향을 주는지 생각하는 일이 그 어느 때보다 중요하다고 생각한다.
2
구조체가 무엇인지 모른다면, 머릿속에서 그냥 클래스로 생각하면 된다.
3
많은 언어에 이것이 있지만, true/false나 C의 enum처럼 빈곤한 형태다.
4
어차피 정적 타입 검사로 그 보장을 얻을 생각이라면, 그것을 중심으로 설계된 언어(enum!)를 사용하고 성능 이점도 얻는 편이 어떨까?
5
AI는 정말로 이해하는가? 철학적 논쟁을 하고 싶은가? _이해하다_는 무슨 뜻인가? 자연어는 본질적으로 확장 가능하다.
6
AI와 함께 대규모 선행 설계가 돌아오는 모습을 보았다. 내가 틀릴 수도 있지만, 나는 여전히 이 접근법에 회의적이며 반복적 개발, 점진적 학습과 이론 구축을 여전히 지지한다.
7
불가능하지는 않다. 나는 그런 사례를 보았다. 사람들이 정말 애쓰면 그렇게 할 수 있고, 그래도 삶을 더 어렵게 만든다. 테스트하기는 훨씬 더 어려워진다. 하지만 적어도 더 명백하고 수행하기 더 어렵다.
8
모든 것을 복제하고 소유하라! 덧붙여 이는 더 연속적인 메모리 레이아웃으로 이어질 수도 있다.
9
메모리도 CPU 시간도 전혀 쓰지 않는다는 것은 과장이지만, 작은 Rust 프로그램은 가끔 그렇게 느껴진다.
10
AI 개발은 소프트웨어 개발의 모든 절충을 바꾸고 있다. 사라진 것은 아니지만 달라졌다. AI는 당신이 Rust를 모르더라도 Rust를 작성할 수 있다. 하지만 나의 Rust 경험과 AI가 AI만으로 얻는 결과보다 더 나은 결과를 이끄는 맥락은 여전히 많이 남아 있다고 믿는다.