조용한 담장

Rust Using Structs to Structure Related Data - Quick Reference

iosroid — Fri, 2 Jan 2026 12:23:21 +0900

5. Using Structs to Structure Related Data

이 글은 Rust 공식 문서 5장(Using Structs to Structure Related Data)의 내용을 기반으로 빠르게 훑어볼 수 있도록 정리한 요약본입니다.

5.1. Defining and Instantiating Structs

https://doc.rust-lang.org/book/ch05-01-defining-structs.html

핵심 개념 및 코드 스니핏

정의 (Definition): struct 키워드로 필드와 타입을 묶음.

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

인스턴스화 (Instantiation): 정의된 키에 값을 할당 (순서 무관).

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

가변성 (Mutability): 인스턴스 전체가 mut여야 필드 변경 가능.

let mut user1 = User { /* ... */ };
user1.email = String::from("another@example.com"); // 가능
// let user2 = User { ... }; user2.email = ...; // 불가능 (컴파일 에러)

필드 초기화 축약 (Field Init Shorthand): 변수명과 필드명이 같으면 생략.

fn build(email: String, username: String) -> User {
    User {
        email,    // email: email 과 동일
        username, // username: username 과 동일
        active: true,
    }
}

구조체 갱신 문법 (Struct Update Syntax): ..instance로 나머지 필드 복사.

// user1의 active 등을 가져오고 email만 새로 설정
let user2 = User {
    email: String::from("new@example.com"),
    ..user1 
};
// 주의: String 같은 힙 데이터 필드가 user1에서 user2로 이동(Move)되면 user1은 재사용 불가

튜플 구조체 (Tuple Structs): 필드명 없는 구조체.

struct Color(i32, i32, i32);
let black = Color(0, 0, 0);
// black.0 으로 접근

유닛 구조체 (Unit-Like Structs): 필드가 없는 구조체 (트레이트 구현용).

struct AlwaysEqual;
let subject = AlwaysEqual;

통합 실전 예제

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

struct Color(i32, i32, i32); // 튜플 구조체
struct AlwaysEqual;          // 유닛 구조체

fn main() {
    // 1. 가변 인스턴스 생성
    let mut user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someusername123"),
        active: true,
    };

    // 2. 필드 값 변경
    user1.email = String::from("another@example.com");

    // 3. 구조체 갱신 문법 (Struct Update Syntax)
    // user1의 username(String) 소유권이 user2로 이동(Move)됨에 주의!
    let user2 = User {
        email: String::from("user2@example.com"),
        ..user1 
    };

    println!("User2 Email: {}", user2.email);
    println!("User2 Username: {}", user2.username); 
    // println!("{}", user1.username); // 컴파일 에러! (소유권 이동됨)
    println!("User1 Active: {}", user1.active); // Copy 타입(bool)은 여전히 사용 가능

    // 4. 튜플 구조체 사용
    let black = Color(0, 0, 0);
    println!("Black Color R: {}, G: {}, B: {}", black.0, black.1, black.2);

    // 5. 유닛 구조체 사용
    let _subject = AlwaysEqual;
}

5.1 Defining and Instantiating Structs - 테스트 코드(Rust Playground)
Gist

5.2. An Example Program Using Structs

https://doc.rust-lang.org/book/ch05-02-example-structs.html

핵심 개념 및 코드 스니핏

의미 부여 (Semantic Grouping): 개별 변수보다 구조체가 데이터의 관계를 명확히 함.

// Bad: fn area(width: u32, height: u32) -> u32
// Good:
struct Rectangle { width: u32, height: u32 }
fn area(rect: &Rectangle) -> u32 { ... }

Debug 트레이트 파생 (Derive Debug): 구조체 출력을 위해 #[derive(Debug)] 추가.

#[derive(Debug)]
struct Rectangle { width: u32, height: u32 }

포맷팅 출력: {:?} 또는 {:#?} 사용.

let rect = Rectangle { width: 30, height: 50 };
println!("rect: {:?}", rect);   // 한 줄 출력
println!("rect: {:#?}", rect);  // 들여쓰기 출력 (Pretty Print)

dbg! 매크로: 디버깅 정보를 stderr로 출력하고 값을 반환.

let width = dbg!(30 * 2); // 60을 출력하고 변수에 할당
dbg!(&rect); // 파일명, 라인번호, 값 출력

통합 실전 예제

#[derive(Debug)] // 구조체를 출력 가능하게 만듦
struct Rectangle {
    width: u32,
    height: u32,
}

fn area(rectangle: &Rectangle) -> u32 {
    rectangle.width * rectangle.height
}

fn main() {
    let scale = 2;
    let rect1 = Rectangle {
        // dbg!는 값을 반환하므로 필드 할당 식 중간에 사용 가능
        width: dbg!(30 * scale), 
        height: 50,
    };

    println!(
        "The area of the rectangle is {} square pixels.",
        area(&rect1)
    );

    // {:?} : 기본적인 Debug 출력
    println!("rect1 is {:?}", rect1);

    // {:#?} : 읽기 편한 Debug 출력
    println!("rect1 is {:#?}", rect1);

    // dbg! 매크로 활용 (소유권을 뺏기지 않으려 참조를 넘김)
    dbg!(&rect1);
}

5.2 An Example Program Using Structs - 테스트 코드(Rust Playground)
Gist

5.3. Methods

https://doc.rust-lang.org/book/ch05-03-method-syntax.html

핵심 개념 및 코드 스니핏

메서드 정의 (impl block): 함수가 아닌 구조체 컨텍스트 내의 메서드.

impl Rectangle {
    fn area(&self) -> u32 { /* ... */ }
}

self 파라미터의 종류:

&self: 읽기 전용 (가장 많이 사용).
&mut self: 인스턴스 내부 값 변경 시 사용.
self: 소유권을 가져감 (메서드 종료 시 인스턴스 해제됨).

impl Rectangle {
    fn read(&self) {}       // 읽기
    fn change(&mut self) {} // 쓰기
    fn consume(self) {}     // 소유권 가져오기
}

연관 함수 (Associated Functions): self가 없는 함수. 주로 생성자(::new)로 사용.

impl Rectangle {
    fn square(size: u32) -> Self { // Self는 Rectangle의 별칭
        Self { width: size, height: size }
    }
}
// 호출: Rectangle::square(10);

다중 impl 블록: 코드를 분리하여 작성 가능.

impl Rectangle { fn area(&self) ... }
impl Rectangle { fn can_hold(&self) ... }

통합 실전 예제

#[derive(Debug)]
struct Rectangle {
    width: u32,
    height: u32,
}

impl Rectangle {
    // 1. 메서드: &self (Immutable Borrow)
    fn area(&self) -> u32 {
        self.width * self.height
    }

    // 2. 메서드: 다른 인스턴스와 상호작용
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }

    // 3. 메서드: 필드명과 동일한 이름 (Getter)
    fn width(&self) -> bool {
        self.width > 0
    }

    // 4. 메서드: &mut self (Mutable Borrow) - 상태 변경
    fn resize(&mut self, factor: u32) {
        self.width *= factor;
        self.height *= factor;
    }
}

// 별도의 impl 블록 (조직화를 위해 분리 가능)
impl Rectangle {
    // 5. 연관 함수: self가 없음 (생성자 역할)
    // 호출 시 :: 연산자 사용
    fn square(size: u32) -> Self {
        Self {
            width: size,
            height: size,
        }
    }
}

fn main() {
    let mut rect1 = Rectangle { width: 30, height: 50 };
    let rect2 = Rectangle { width: 10, height: 40 };
    let rect3 = Rectangle { width: 60, height: 45 };

    // 연관 함수 호출 (::)
    let sq = Rectangle::square(20); 

    println!("Area of rect1: {}", rect1.area()); // 자동 참조/역참조 기능으로 (&rect1).area()와 동일

    // 메서드와 필드 이름이 같을 경우, 괄호() 유무로 구분
    if rect1.width() {
        println!("Rect1 width exists: {}", rect1.width);
    }

    println!("Can rect1 hold rect2? {}", rect1.can_hold(&rect2));
    println!("Can rect1 hold rect3? {}", rect1.can_hold(&rect3));

    // 상태 변경 메서드 호출
    rect1.resize(2);
    println!("Resized rect1: {:#?}", rect1);

    println!("Square constructed: {:?}", sq);
}

5.3 Methods - 테스트 코드(Rust Playground)
Gist

Rust Understanding Ownership - Quick Reference

iosroid — Mon, 29 Dec 2025 22:37:55 +0900

이 글은 Rust 공식 문서 4장(Understanding Ownership)의 내용을 기반으로 빠르게 훑어볼 수 있도록 정리한 요약본입니다.

4. Understanding Ownership

Rust가 가비지 컬렉터 없이 메모리 안전성을 보장하는 핵심 메커니즘입니다.
"누가 메모리를 해제할 책임이 있는가?"를 결정하는 규칙들의 집합입니다.

4.1. What Is Ownership?

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

The 3 Rules

Rust의 각각의 값은 해당 값의 Owner(소유자)라고 불리는 변수가 있다.
한 번에 딱 하나의 Owner만 존재할 수 있다.
Owner가 스코프 밖으로 벗어나면, 값은 버려진다(Dropped).

메모리 동작: Move vs Copy

데이터 타입이 힙(Heap)을 쓰느냐 스택(Stack)을 쓰느냐에 따라 대입 연산의 동작이 다릅니다.

Case 1: Move (힙 데이터 - String 등)

힙에 저장되는 데이터는 변수 대입 시 얕은 복사(포인터 복사)가 일어나며, 기존 변수는 무효화됩니다. 이를 Move라고 합니다.

#[test]
fn test_ownership_move() {
    let s1 = String::from("hello");
    let s2 = s1; // 소유권이 s2로 이동(Move)됨.

    // println!("{}, world!", s1); // 컴파일 에러! s1은 이제 유효하지 않음 (Use of moved value)
    println!("{}, world!", s2); // 정상 작동
}

Case 2: Copy (스택 데이터 - 정수, 불리언 등)

크기가 고정된 스택 데이터는 Copy 트레이트가 구현되어 있어, 대입 시 값이 자동 복사됩니다. 기존 변수도 계속 사용 가능합니다.

#[test]
fn test_stack_copy() {
    let x = 5;
    let y = x; // x의 값이 복사되어 y에 할당됨.

    println!("x = {}, y = {}", x, y); // 둘 다 사용 가능
}

Case 3: Clone (깊은 복사)

힙 데이터를 그대로 유지하면서 새로 하나 더 만들고 싶다면 .clone()을 명시적으로 호출해야 합니다.

#[test]
fn test_deep_copy() {
    let s1 = String::from("hello");
    let s2 = s1.clone(); // 힙 메모리 데이터까지 완전히 복사 (비용 발생)

    println!("s1 = {}, s2 = {}", s1, s2); // 둘 다 사용 가능
}

Quick Tip:

함수에 값을 전달할 때도 Move가 발생합니다. 값을 함수에 넘겨주고 다시 쓰고 싶다면 반환값으로 돌려받거나, 아래의 '참조(Reference)'를 써야 합니다.

4.1. What Is Ownership? - 테스트 코드(Rust Playground)
Gist

4.2 References and Borrowing

https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html

소유권을 넘기지(Move) 않고 값에 접근하고 싶을 때 사용합니다. & 기호를 사용합니다.

참조의 규칙 (The Rules of References)

어느 한 시점에 코드는 하나의 가변 참조자(&mut) 또는 여러 개의 불변 참조자(&) 중 하나만 가질 수 있다. (동시 존재 불가)
참조자는 항상 유효해야 한다. (Dangling Reference 불가)

불변 참조 (`&T`) vs 가변 참조 (`&mut T`)

1. 여러 개의 불변 참조 (Read-Only)

읽기만 한다면 몇 명이든 상관없습니다.

#[test]
fn test_immutable_borrow() {
    let s = String::from("hello");
    let r1 = &s; // 불변 참조 1
    let r2 = &s; // 불변 참조 2

    println!("{}, {}", r1, r2); // 문제 없음
}

2. 단 하나의 가변 참조 (Read-Write)

수정 권한은 오직 한 명에게만 주어집니다. 데이터 레이스(Data Race)를 원천 차단합니다.

#[test]
fn test_mutable_borrow() {
    let mut s = String::from("hello");

    let r1 = &mut s; 
    // let r2 = &mut s; // 컴파일 에러! (Second mutable borrow occurs here)

    r1.push_str(", world");
    println!("{}", r1);
}

3. 불변과 가변의 혼용 불가

"보고 있는데 누가 수정하면 안 된다"는 원칙입니다.

#[test]
fn test_mixed_borrow() {
    let mut s = String::from("hello");

    let r1 = &s; // 불변 참조
    let r2 = &s; // 불변 참조
    // let r3 = &mut s; // 컴파일 에러! (불변 참조가 살아있는 동안 가변 참조 불가)

    println!("{}, {}", r1, r2); 

    // NLL (Non-Lexical Lifetimes):
    // r1, r2가 여기서 마지막으로 사용되었으므로, 이 시점 이후부터는 가변 참조 가능
    let r3 = &mut s; 
    r3.push_str(" world");
    println!("{}", r3); // 최신 Rust 컴파일러는 여기서 문제 없음
}

** Quick Tip (Dangling Reference):**
함수 내에서 생성한 로컬 변수의 참조(reference)를 리턴하면 안 됩니다. 함수가 끝나면 로컬 변수는 Drop되는데, 포인터만 리턴하려 하기 때문입니다. 이럴 땐 값을 직접 리턴(Move)하세요.

4.2 References and Borrowing - 테스트 코드(Rust Playground)
Gist

4.3 The Slice Type

https://doc.rust-lang.org/book/ch04-03-slices.html

소유권을 갖지 않고(Borrow), 컬렉션(배열, 문자열 등)의 연속된 일부분을 참조하는 뷰(View)입니다.

문자열 슬라이스 (`&str`)

String의 일부분을 가리킵니다. 내부적으로 ptr(시작 위치)와 len(길이)만 저장합니다.

#[test]
fn test_string_slices() {
    let s = String::from("Hello World");

    let hello = &s[0..5]; // 인덱스 0부터 4까지
    let world = &s[6..11]; // 인덱스 6부터 10까지

    assert_eq!(hello, "Hello");
    assert_eq!(world, "World");

    // 전체 슬라이스 문법
    let slice = &s[..]; 
}

문자열 리터럴은 슬라이스다

코드에 박혀있는 문자열은 바이너리 어딘가를 가리키는 슬라이스입니다.

let s: &str = "Hello"; // s는 바이너리 데이터 영역의 특정 위치를 가리키는 슬라이스

배열 슬라이스 (`&[T]`)

문자열뿐만 아니라 일반 배열도 슬라이싱 가능합니다.

#[test]
fn test_array_slices() {
    let a = [1, 2, 3, 4, 5];
    let slice = &a[1..3]; // [2, 3]

    assert_eq!(slice, &[2, 3]);
}

실전 팁: 함수 파라미터 설계

함수 파라미터로 문자열을 받을 때 &String보다 &str을 사용하는 것이 훨씬 유연합니다.

// Bad: String 객체의 참조만 받을 수 있음
fn bad_greet(name: &String) { /* ... */ }

// Good: String의 참조도 받고, 문자열 리터럴("...")도 받을 수 있음
fn good_greet(name: &str) { 
    println!("Hello, {}!", name);
}

#[test]
fn test_api_design() {
    let my_name = String::from("Rust");

    // bad_greet("Rust"); // 컴파일 에러 (타입 불일치)
    bad_greet(&my_name); // 가능

    good_greet("Rust");   // 리터럴 가능 (&str)
    good_greet(&my_name); // String 참조 가능 (Deref Coercion에 의해 &String -> &str 자동 변환)
    good_greet(&my_name[0..1]); // 슬라이스 가능
}

4.3 The Slice Type - 테스트 코드(Rust Playground)
Gist

Rust Common Programming Concepts - Quick Reference

iosroid — Mon, 22 Dec 2025 17:33:49 +0900

3. Rust Common Programming Concepts - Quick Reference

이 글은 Rust 공식 문서 3장(Common Programming Concepts)의 내용을 기반으로 빠르게 훑어볼 수 있도록 정리한 요약본입니다.

3.1 Variables and Mutability

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

핵심 개념

기본값: 불변(immutable)
가변 변수는 mut 키워드 필요
섀도잉(shadowing)으로 타입 변경 가능
상수는 const 키워드 사용

불변 변수 (기본)

fn test_immutable() {
    let x = 5;
    println!("x = {}", x);
    // x = 6;  // error[E0384]: cannot assign twice to immutable variable
}

가변 변수

fn test_mutable() {
    let mut x = 5;
    println!("Before: {}", x);
    x = 6;  // OK
    println!("After: {}", x);

    // 출력:
    // Before: 5
    // After: 6
}

섀도잉 (Shadowing)

fn test_shadowing() {
    // 1. 같은 타입 섀도잉
    let x = 5;
    let x = x + 1;  // 6
    let x = x * 2;  // 12
    println!("x = {}", x);  // 12

    // 2. 다른 타입으로 섀도잉 (타입 변환)
    let spaces = "   ";
    let spaces = spaces.len();  // &str -> usize
    println!("spaces = {}", spaces);  // 3

    // 3. mut는 타입 변경 불가
    let mut count = "   ";
    // count = count.len();  // 에러! 타입이 다름
}

섀도잉 스코프

fn test_shadowing_scope() {
    let x = 5;

    {
        let x = x * 2;  // 내부 스코프에서만 유효
        println!("Inner: x = {}", x);  // 10
    }

    println!("Outer: x = {}", x);  // 5
}

상수 (Constants)

// 전역 상수 - 타입 명시 필수
const MAX_POINTS: u32 = 100_000;
const THREE_HOURS_IN_SECONDS: u32 = 60 * 60 * 3;

fn test_constants() {
    // 함수 내부 상수
    const THRESHOLD: f64 = 0.5;

    println!("Max points: {}", MAX_POINTS);
    println!("Threshold: {}", THRESHOLD);

    // const는 mut 불가
    // const mut VALUE: i32 = 10;  // 에러
}

실전 팁

mut vs shadowing 선택 기준:

fn practical_examples() {
    // mut 사용: 같은 타입의 값을 계속 변경
    let mut counter = 0;
    for _ in 0..10 {
        counter += 1;
    }

    // shadowing 사용: 타입 변환 파이프라인
    let input = "  42  ";
    let input = input.trim();           // &str
    let input = input.parse::<i32>();   // Result<i32, _>
    let input = input.unwrap();         // i32
    println!("Parsed: {}", input);

    // shadowing 사용: 중간 계산 결과 저장
    let width = 10;
    let width = width * 2;      // 단위 변환
    let width = width + 5;      // 여백 추가
}

성능 고려사항:

fn performance_consideration() {
    // 큰 데이터 구조는 mut가 효율적
    let mut large_vec = vec![0; 1_000_000];
    for i in 0..large_vec.len() {
        large_vec[i] = i;  // in-place 수정
    }

    // 작은 데이터는 불변 + 함수형 스타일도 OK
    let small_vec = vec![1, 2, 3];
    let doubled = small_vec.iter().map(|x| x * 2).collect::<Vec<_>>();
}

3.1 Variables and Mutability - 테스트 코드(Rust Playground)
Gist

3.2 Data Types

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

핵심 개념

정적 타입 언어 - 컴파일 시 모든 타입 결정
타입 추론 지원 (대부분 명시 불필요)
스칼라 타입: 정수, 부동소수점, 불리언, 문자
복합 타입: 튜플, 배열

정수 타입 (Integer Types)

fn test_integer_types() {
    // 부호 있음: i8, i16, i32(기본), i64, i128, isize
    let a: i8 = -128;       // -128 ~ 127
    let b: i32 = 42;        // 기본 타입
    let c: i64 = 1_000_000; // 언더스코어로 가독성

    // 부호 없음: u8, u16, u32, u64, u128, usize
    let d: u8 = 255;        // 0 ~ 255
    let e: u32 = 100_000;

    // 아키텍처 의존 타입
    let f: isize = 100;     // 32bit: i32, 64bit: i64
    let g: usize = 100;     // 배열 인덱스 등에 사용

    // 리터럴 표기법
    let decimal = 98_222;
    let hex = 0xff;             // 255
    let octal = 0o77;           // 63
    let binary = 0b1111_0000;   // 240
    let byte = b'A';            // u8만 가능, 65

    println!("hex: {}, octal: {}, binary: {}, byte: {}", 
             hex, octal, binary, byte);
}

정수 오버플로우 처리

fn test_overflow() {
    let mut x: u8 = 255;

    // 디버그 모드: panic
    // 릴리즈 모드: 2의 보수 래핑 (0이 됨)
    // x = x + 1;  // 주의

    // 명시적 오버플로우 처리 메서드

    // 1. wrapping_* : 항상 래핑
    let wrapped = x.wrapping_add(1);
    println!("wrapped: {}", wrapped);  // 0

    // 2. checked_* : Option 반환
    match x.checked_add(1) {
        Some(val) => println!("OK: {}", val),
        None => println!("Overflow detected!"),  // 이 경로 실행
    }

    // 3. saturating_* : 최대/최소값 고정
    let saturated = x.saturating_add(1);
    println!("saturated: {}", saturated);  // 255

    // 4. overflowing_* : (결과, 오버플로우 여부) 반환
    let (result, overflowed) = x.overflowing_add(1);
    println!("result: {}, overflowed: {}", result, overflowed);
    // result: 0, overflowed: true
}

부동소수점 (Floating-Point Types)

fn test_floating_point() {
    let x = 2.0;        // f64 (기본)
    let y: f32 = 3.0;   // f32

    // 연산
    let sum = 5.0 + 10.0;
    let difference = 95.5 - 4.3;
    let product = 4.0 * 30.0;
    let quotient = 56.7 / 32.2;
    let remainder = 43.0 % 5.0;

    // 부동소수점 비교 주의
    let a = 0.1 + 0.2;
    let b = 0.3;
    // a == b  // false! (부동소수점 오차)

    // 올바른 비교
    let epsilon = f64::EPSILON;
    if (a - b).abs() < epsilon {
        println!("거의 같음");
    }

    // 특수값
    let inf = f64::INFINITY;
    let neg_inf = f64::NEG_INFINITY;
    let nan = f64::NAN;

    println!("Is NaN: {}", nan.is_nan());
    println!("Is infinite: {}", inf.is_infinite());
}

불리언 (Boolean Type)

fn test_boolean() {
    let t = true;
    let f: bool = false;

    // 1바이트 크기
    println!("Size of bool: {}", std::mem::size_of::<bool>());  // 1

    // 논리 연산
    let and = t && f;
    let or = t || f;
    let not = !t;

    // 비교 연산 결과
    let is_greater = 5 > 3;  // true
}

문자 (Character Type)

fn test_char() {
    let c = 'z';
    let emoji = ' ';
    let heart = '❤';
    let hangul = '한';

    // 4바이트 유니코드 스칼라 값
    println!("Size: {}", std::mem::size_of::<char>());  // 4

    // 문자열과 다름
    let char_literal = 'a';      // char
    let str_literal = "a";       // &str
    // let wrong = 'ab';         // 에러: 단일 문자만
}

튜플 (Tuple Type)

fn test_tuple() {
    // 1. 기본 선언
    let tup: (i32, f64, u8) = (500, 6.4, 1);

    // 2. 분해 (destructuring)
    let (x, y, z) = tup;
    println!("x: {}, y: {}, z: {}", x, y, z);

    // 3. 인덱스 접근 (점 표기법)
    let five_hundred = tup.0;
    let six_point_four = tup.1;
    let one = tup.2;

    // 4. 빈 튜플 = unit 타입
    let unit: () = ();

    // 5. 단일 요소 튜플
    let single = (5,);  // 쉼표 필수
    // let not_tuple = (5);  // 이건 그냥 정수
}

튜플 활용 예제

fn swap(pair: (i32, i32)) -> (i32, i32) {
    let (a, b) = pair;
    (b, a)  // 교환된 튜플 반환
}

fn divide(dividend: i32, divisor: i32) -> (i32, i32) {
    (dividend / divisor, dividend % divisor)  // (몫, 나머지)
}

fn test_tuple_usage() {
    let pair = (5, 10);
    let swapped = swap(pair);
    println!("Original: {:?}, Swapped: {:?}", pair, swapped);

    let (quotient, remainder) = divide(17, 5);
    println!("17 / 5 = {} remainder {}", quotient, remainder);
}

배열 (Array Type)

fn test_array() {
    // 1. 기본 선언
    let a = [1, 2, 3, 4, 5];
    let b: [i32; 5] = [1, 2, 3, 4, 5];  // 타입 명시

    // 2. 같은 값으로 초기화
    let zeros = [0; 5];     // [0, 0, 0, 0, 0]
    let threes = [3; 10];   // 10개의 3

    // 3. 인덱스 접근
    let first = a[0];
    let second = a[1];

    // 4. 크기 확인
    println!("Length: {}", a.len());

    // 5. 메모리 크기 (스택 할당)
    println!("Size: {} bytes", std::mem::size_of_val(&a));
    // i32 * 5 = 20 bytes
}

배열 주의사항

fn test_array_bounds() {
    let a = [1, 2, 3, 4, 5];

    // 유효한 인덱스
    let element = a[2];
    println!("Element: {}", element);

    // 범위 초과 - 런타임 패닉
    // let invalid = a[10];  // thread 'main' panicked

    // 안전한 접근
    if let Some(&value) = a.get(2) {
        println!("Safe access: {}", value);
    }

    match a.get(10) {
        Some(&value) => println!("Found: {}", value),
        None => println!("Index out of bounds"),
    }
}

배열 반복

fn test_array_iteration() {
    let a = [10, 20, 30, 40, 50];

    // 1. for 루프로 값 순회
    for element in a {
        println!("Value: {}", element);
    }

    // 2. iter()로 참조 순회
    for element in a.iter() {
        println!("Ref: {}", element);
    }

    // 3. 인덱스와 값 함께
    for (index, &value) in a.iter().enumerate() {
        println!("a[{}] = {}", index, value);
    }

    // 4. 가변 반복 (배열은 고정 크기이므로 드묾)
    let mut b = [1, 2, 3];
    for element in b.iter_mut() {
        *element *= 2;
    }
    println!("{:?}", b);  // [2, 4, 6]
}

배열 vs 벡터

fn test_array_vs_vector() {
    // 배열: 고정 크기, 스택, 컴파일 타임 크기 결정
    let array: [i32; 5] = [1, 2, 3, 4, 5];
    // array.push(6);  // 메서드 없음

    // 벡터: 동적 크기, 힙, 런타임 크기 변경 가능
    let mut vector = vec![1, 2, 3, 4, 5];
    vector.push(6);  // OK
    println!("Vector: {:?}", vector);

    // 배열 -> 슬라이스
    let slice: &[i32] = &array[1..3];
    println!("Slice: {:?}", slice);  // [2, 3]
}

타입 변환

fn test_type_conversion() {
    // 1. as 키워드 (명시적 캐스팅)
    let integer: i32 = 42;
    let float = integer as f64;
    let byte = integer as u8;

    // 2. 문자열 -> 숫자
    let num: i32 = "42".parse().unwrap();
    let num: i32 = "42".parse::<i32>().unwrap();  // 터보피시

    // 3. 숫자 -> 문자열
    let s = 42.to_string();
    let s = format!("{}", 42);

    // 4. From/Into 트레이트
    let s = String::from("hello");
    let s: String = "hello".into();

    // 5. TryFrom (실패 가능한 변환)
    use std::convert::TryFrom;
    match i32::try_from(300u16) {
        Ok(n) => println!("Converted: {}", n),
        Err(e) => println!("Conversion failed: {}", e),
    }
}

타입 선택 가이드

fn type_selection_guide() {
    // 정수 기본: i32 (성능과 범위 균형)
    let default_int = 42;

    // 배열 인덱스, 크기: usize
    let arr = [1, 2, 3, 4, 5];
    for i in 0..arr.len() {  // len()은 usize 반환
        println!("{}", arr[i]);
    }

    // 바이트 데이터: u8
    let bytes: Vec<u8> = vec![0x48, 0x65, 0x6C, 0x6C, 0x6F];

    // 고정 크기 필요: 배열
    let weekdays: [&str; 7] = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"];

    // 동적 크기 필요: Vec
    let mut dynamic_list = Vec::new();
    dynamic_list.push(1);
    dynamic_list.push(2);
}

3.2 Data Types - 테스트 코드(Rust Playground)
Gist

3.3 Functions

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

핵심 개념

fn 키워드로 정의
snake_case 명명 규칙
매개변수는 반드시 타입 명시
반환 타입은 -> 뒤에 명시
표현식 기반: 마지막 표현식이 반환값

기본 함수 선언

fn main() {
    println!("Hello from main!");
    another_function();
    function_with_params(5, 10);
}

fn another_function() {
    println!("Another function");
}

fn function_with_params(x: i32, y: i32) {
    println!("x: {}, y: {}", x, y);
}

함수 반환값

// 1. 표현식으로 반환 (세미콜론 없음)
fn five() -> i32 {
    5  // 표현식
}

fn add(a: i32, b: i32) -> i32 {
    a + b  // 마지막 표현식이 반환값
}

// 2. 명시적 return
fn subtract(a: i32, b: i32) -> i32 {
    return a - b;  // 일찍 반환할 때 유용
}

// 3. 여러 return 경로
fn abs_difference(a: i32, b: i32) -> i32 {
    if a > b {
        return a - b;  // 일찍 반환
    }
    b - a  // 마지막 표현식
}

fn test_returns() {
    assert_eq!(five(), 5);
    assert_eq!(add(2, 3), 5);
    assert_eq!(subtract(10, 3), 7);
    assert_eq!(abs_difference(10, 5), 5);
    assert_eq!(abs_difference(5, 10), 5);
}

표현식 vs 문

fn test_expression_vs_statement() {
    // 문(Statement): 값을 반환하지 않음
    let y = 6;  // 값 바인딩은 문

    // let x = (let y = 6);  // 에러: let은 값이 없음

    // 표현식(Expression): 값을 평가
    let x = 5;  // 5는 표현식
    let y = {
        let x = 3;
        x + 1  // 4를 반환 (세미콜론 없음)
    };
    println!("y: {}", y);  // 4

    // 세미콜론이 있으면 ()를 반환
    let z = {
        let x = 3;
        x + 1;  // 세미콜론 -> 문
    };  // z의 타입은 ()
}

세미콜론의 중요성

// 잘못된 반환
fn wrong_return() -> i32 {
    let x = 5;
    x + 1;  // 세미콜론 때문에 () 반환
            // error: mismatched types
}

// 올바른 반환
fn correct_return() -> i32 {
    let x = 5;
    x + 1  // 세미콜론 없음 -> 표현식
}

// 명시적 return 사용
fn explicit_return() -> i32 {
    let x = 5;
    return x + 1;  // 세미콜론 있어도 OK
}

함수 매개변수 패턴

// 1. 튜플 분해
fn print_coordinates((x, y): (i32, i32)) {
    println!("x: {}, y: {}", x, y);
}

// 2. 참조 매개변수
fn calculate_length(s: &String) -> usize {
    s.len()
}

// 3. 가변 참조
fn change(s: &mut String) {
    s.push_str(", world");
}

fn test_parameters() {
    print_coordinates((10, 20));

    let s = String::from("hello");
    let len = calculate_length(&s);
    println!("Length: {}", len);

    let mut s = String::from("hello");
    change(&mut s);
    println!("{}", s);  // "hello, world"
}

다중 반환값

// 튜플로 여러 값 반환
fn swap(pair: (i32, i32)) -> (i32, i32) {
    let (a, b) = pair;
    (b, a)
}

fn divide_with_remainder(dividend: i32, divisor: i32) -> (i32, i32) {
    (dividend / divisor, dividend % divisor)
}

fn analyze_number(n: i32) -> (bool, bool, i32) {
    let is_positive = n > 0;
    let is_even = n % 2 == 0;
    let absolute = n.abs();
    (is_positive, is_even, absolute)
}

fn test_multiple_returns() {
    let (a, b) = swap((1, 2));
    println!("Swapped: ({}, {})", a, b);

    let (quotient, remainder) = divide_with_remainder(17, 5);
    println!("17 / 5 = {} R {}", quotient, remainder);

    let (positive, even, abs_val) = analyze_number(-42);
    println!("Positive: {}, Even: {}, Abs: {}", positive, even, abs_val);
}

재귀 함수

fn factorial(n: u32) -> u32 {
    if n == 0 {
        1
    } else {
        n * factorial(n - 1)
    }
}

fn fibonacci(n: u32) -> u32 {
    match n {
        0 => 0,
        1 => 1,
        _ => fibonacci(n - 1) + fibonacci(n - 2),
    }
}

fn test_recursion() {
    println!("5! = {}", factorial(5));  // 120
    println!("fib(10) = {}", fibonacci(10));  // 55
}

함수 설계 팁

// 작고 명확한 책임
fn is_even(n: i32) -> bool {
    n % 2 == 0
}

fn is_prime(n: u32) -> bool {
    if n < 2 { return false; }
    for i in 2..=(n as f64).sqrt() as u32 {
        if n % i == 0 { return false; }
    }
    true
}

// 조기 반환으로 가독성 향상
fn process_value(value: Option<i32>) -> i32 {
    // None 체크를 먼저
    let val = match value {
        Some(v) => v,
        None => return 0,
    };

    // 음수 체크
    if val < 0 {
        return -val;
    }

    // 일반 케이스
    val * 2
}

// 타입 별칭으로 명확성
type Point = (i32, i32);
type Result<T> = std::result::Result<T, String>;

fn distance(p1: Point, p2: Point) -> f64 {
    let (x1, y1) = p1;
    let (x2, y2) = p2;
    (((x2 - x1).pow(2) + (y2 - y1).pow(2)) as f64).sqrt()
}

3.4 Comments

https://doc.rust-lang.org/book/ch03-04-comments.html

핵심 개념

일반 주석: // (한 줄), /* */ (여러 줄)
문서 주석: /// (외부), //! (내부)
문서 주석은 Markdown 지원
cargo doc으로 문서 생성

일반 주석

fn test_comments() {
    // 한 줄 주석
    let x = 5;  // 코드 뒤 주석도 가능

    /*
     * 여러 줄 주석
     * 두 번째 줄
     */
    let y = 10;

    /* 중첩 /* 주석 */ 가능 */

    // 코드 주석 처리
    // let unused = 42;
}

문서 주석 - 외부

/// 두 수를 더합니다.
///
/// # Examples
///
/// ```
/// let result = add(2, 3);
/// assert_eq!(result, 5);
/// ```
///
/// # Arguments
///
/// * `a` - 첫 번째 숫자
/// * `b` - 두 번째 숫자
///
/// # Returns
///
/// 두 숫자의 합
fn add(a: i32, b: i32) -> i32 {
    a + b
}

/// 숫자가 짝수인지 확인합니다.
///
/// # Panics
///
/// 이 함수는 패닉하지 않습니다.
///
/// # Safety
///
/// 이 함수는 안전합니다.
fn is_even(n: i32) -> bool {
    n % 2 == 0
}

문서 주석 - 내부

//! 수학 연산을 위한 유틸리티 모듈
//!
//! 이 모듈은 기본적인 수학 연산 함수들을 제공합니다.
//!
//! # Examples
//!
//! ```
//! use my_crate::math;
//! let sum = math::add(2, 3);
//! ```

pub mod math {
    //! 수학 함수 모듈

    /// 덧셈 수행
    pub fn add(a: i32, b: i32) -> i32 {
        a + b
    }
}

문서 주석 섹션들

/// 복잡한 계산을 수행합니다.
///
/// # Arguments
///
/// * `input` - 입력값
///
/// # Returns
///
/// 계산 결과
///
/// # Examples
///
/// ```
/// let result = complex_calculation(42);
/// assert_eq!(result, 84);
/// ```
///
/// # Panics
///
/// `input`이 음수일 때 패닉합니다.
///
/// # Errors
///
/// 이 함수는 에러를 반환하지 않습니다.
///
/// # Safety
///
/// 이 함수는 unsafe 블록을 포함하지 않습니다.
fn complex_calculation(input: i32) -> i32 {
    assert!(input >= 0, "Input must be non-negative");
    input * 2
}

주석 작성 팁

// 나쁜 주석: 코드를 그대로 설명
// x에 5를 할당
let x = 5;

// 좋은 주석: 왜 이렇게 했는지 설명
// 성능 최적화를 위해 버퍼 크기를 미리 할당
let mut buffer = Vec::with_capacity(1000);

// 복잡한 로직 설명
// Boyer-Moore 알고리즘을 사용하여 검색 성능 향상
// O(n) -> O(n/m) 복잡도 개선
fn search_pattern(text: &str, pattern: &str) -> Option<usize> {
    // implementation
    None
}

// TODO, FIXME, HACK 표시
// TODO: 에러 처리 추가 필요
// FIXME: 메모리 누수 가능성
// HACK: 임시 방편, 나중에 리팩토링 필요

3.5 Control Flow

https://doc.rust-lang.org/book/ch03-05-control-flow.html

핵심 개념

if, else if, else - 조건 분기
loop - 무한 루프
while - 조건 루프
for - 컬렉션 순회
모든 제어문이 표현식 (값을 반환할 수 있음)

if 표현식

fn test_if() {
    let number = 6;

    // 1. 기본 if
    if number < 5 {
        println!("true");
    } else {
        println!("false");
    }

    // 2. else if
    if number % 4 == 0 {
        println!("divisible by 4");
    } else if number % 3 == 0 {
        println!("divisible by 3");
    } else if number % 2 == 0 {
        println!("divisible by 2");
    } else {
        println!("not divisible by 4, 3, or 2");
    }

    // 3. if를 표현식으로 사용
    let condition = true;
    let value = if condition { 5 } else { 6 };
    println!("value: {}", value);

    // 4. 모든 분기가 같은 타입 반환해야 함
    // let wrong = if condition { 5 } else { "six" };  // 에러
}

if를 이용한 패턴

fn test_if_patterns() {
    let number = 7;

    // 1. 범위 체크
    let category = if number < 0 {
        "negative"
    } else if number == 0 {
        "zero"
    } else if number < 10 {
        "single digit"
    } else {
        "multiple digits"
    };

    // 2. 조기 반환
    fn check_positive(n: i32) -> Result<i32, String> {
        if n <= 0 {
            return Err("Not positive".to_string());
        }
        Ok(n * 2)
    }

    // 3. if let 패턴 (Option/Result 처리)
    let some_value = Some(7);
    if let Some(x) = some_value {
        println!("Got: {}", x);
    }
}

loop - 무한 루프

fn test_loop() {
    let mut counter = 0;

    // 1. 기본 무한 루프
    loop {
        counter += 1;
        if counter == 5 {
            break;
        }
    }
    println!("Counter: {}", counter);

    // 2. loop에서 값 반환
    let result = loop {
        counter += 1;
        if counter == 10 {
            break counter * 2;  // 20 반환
        }
    };
    println!("Result: {}", result);

    // 3. 레이블로 중첩 루프 제어
    'outer: loop {
        println!("Outer loop");

        'inner: loop {
            println!("Inner loop");
            break 'outer;  // 외부 루프 탈출
        }

        println!("This will never print");
    }
}

while 루프

fn test_while() {
    let mut number = 3;

    // 1. 기본 while
    while number != 0 {
        println!("{}!", number);
        number -= 1;
    }
    println!("LIFTOFF!");

    // 2. while let 패턴
    let mut stack = vec![1, 2, 3];
    while let Some(top) = stack.pop() {
        println!("Popped: {}", top);
    }

    // 3. 조건이 복잡한 경우
    let mut x = 0;
    while x < 100 && x * x < 500 {
        x += 1;
    }
    println!("x: {}", x);
}

for 루프

fn test_for() {
    let a = [10, 20, 30, 40, 50];

    // 1. 배열 순회 (소유권 이동)
    for element in a {
        println!("Value: {}", element);
    }

    // 2. 참조로 순회
    for element in a.iter() {
        println!("Ref: {}", element);
    }

    // 3. 범위 순회
    for i in 0..5 {  // 0, 1, 2, 3, 4
        println!("{}", i);
    }

    for i in 0..=5 {  // 0, 1, 2, 3, 4, 5 (inclusive)
        println!("{}", i);
    }

    // 4. 역순
    for i in (1..4).rev() {  // 3, 2, 1
        println!("{}!", i);
    }

    // 5. 인덱스와 값
    for (index, value) in a.iter().enumerate() {
        println!("a[{}] = {}", index, value);
    }

    // 6. 가변 반복자
    let mut v = vec![1, 2, 3];
    for item in v.iter_mut() {
        *item *= 2;
    }
    println!("{:?}", v);  // [2, 4, 6]
}

break와 continue

fn test_break_continue() {
    // 1. continue - 다음 반복으로
    for i in 0..10 {
        if i % 2 == 0 {
            continue;  // 짝수는 건너뛰기
        }
        println!("Odd: {}", i);
    }

    // 2. break - 루프 탈출
    let mut sum = 0;
    for i in 1.. {  // 무한 범위
        sum += i;
        if sum > 100 {
            println!("Stopped at i = {}", i);
            break;
        }
    }

    // 3. 레이블과 함께 사용
    'outer: for x in 0..5 {
        for y in 0..5 {
            if x * y > 10 {
                break 'outer;  // 외부 루프 탈출
            }
            println!("x: {}, y: {}", x, y);
        }
    }
}

제어 흐름 비교

fn compare_control_flow() {
    let data = vec![1, 2, 3, 4, 5];

    // 1. 정확한 횟수 반복 -> for
    for i in 0..5 {
        println!("{}", i);
    }

    // 2. 조건이 명확 -> while
    let mut count = 0;
    while count < 5 {
        println!("{}", count);
        count += 1;
    }

    // 3. 무한 루프, 중간에 break -> loop
    let mut sum = 0;
    loop {
        sum += 1;
        if sum > 100 {
            break;
        }
    }

    // 4. 컬렉션 순회 -> for
    for item in data.iter() {
        println!("{}", item);
    }
}

실전 제어 흐름 패턴

// 1. 입력 검증
fn validate_input(value: i32) -> Result<i32, String> {
    if value < 0 {
        return Err("Value must be non-negative".to_string());
    }
    if value > 100 {
        return Err("Value must be <= 100".to_string());
    }
    Ok(value)
}

// 2. 재시도 로직
fn retry_with_limit<F>(mut operation: F, max_attempts: u32) -> Result<(), String>
where
    F: FnMut() -> Result<(), String>,
{
    for attempt in 1..=max_attempts {
        match operation() {
            Ok(_) => return Ok(()),
            Err(e) if attempt == max_attempts => {
                return Err(format!("Failed after {} attempts: {}", max_attempts, e));
            }
            Err(_) => continue,
        }
    }
    unreachable!()
}

// 3. 조기 반환으로 중첩 제거
fn process_data(data: Option<Vec<i32>>) -> i32 {
    // 중첩된 if
    // if let Some(vec) = data {
    //     if !vec.is_empty() {
    //         if vec[0] > 0 {
    //             return vec[0] * 2;
    //         }
    //     }
    // }

    // 조기 반환
    let vec = match data {
        Some(v) => v,
        None => return 0,
    };

    if vec.is_empty() {
        return 0;
    }

    if vec[0] <= 0 {
        return 0;
    }

    vec[0] * 2
}

// 4. 상태 머신 패턴
enum State { Start, Processing, Done }

fn state_machine() {
    let mut state = State::Start;
    let mut count = 0;

    loop {
        state = match state {
            State::Start => {
                println!("Starting...");
                State::Processing
            }
            State::Processing => {
                count += 1;
                println!("Processing... {}", count);
                if count >= 3 {
                    State::Done
                } else {
                    State::Processing
                }
            }
            State::Done => {
                println!("Done!");
                break;
            }
        };
    }
}

종합 예제

FizzBuzz (다양한 구현)

// 1. if-else 버전
fn fizzbuzz_if(n: u32) {
    for i in 1..=n {
        if i % 15 == 0 {
            println!("FizzBuzz");
        } else if i % 3 == 0 {
            println!("Fizz");
        } else if i % 5 == 0 {
            println!("Buzz");
        } else {
            println!("{}", i);
        }
    }
}

// 2. match 버전
fn fizzbuzz_match(n: u32) {
    for i in 1..=n {
        match (i % 3, i % 5) {
            (0, 0) => println!("FizzBuzz"),
            (0, _) => println!("Fizz"),
            (_, 0) => println!("Buzz"),
            _ => println!("{}", i),
        }
    }
}

// 3. 함수형 스타일
fn fizzbuzz_functional(n: u32) {
    (1..=n).for_each(|i| {
        let output = match (i % 3, i % 5) {
            (0, 0) => "FizzBuzz".to_string(),
            (0, _) => "Fizz".to_string(),
            (_, 0) => "Buzz".to_string(),
            _ => i.to_string(),
        };
        println!("{}", output);
    });
}

소수 판별 및 생성

fn is_prime(n: u32) -> bool {
    if n <= 1 {
        return false;
    }
    if n <= 3 {
        return true;
    }
    if n % 2 == 0 || n % 3 == 0 {
        return false;
    }

    let mut i = 5;
    while i * i <= n {
        if n % i == 0 || n % (i + 2) == 0 {
            return false;
        }
        i += 6;
    }

    true
}

fn primes_up_to(limit: u32) -> Vec<u32> {
    (2..=limit).filter(|&n| is_prime(n)).collect()
}

fn nth_prime(n: usize) -> u32 {
    let mut count = 0;
    let mut num = 2;

    loop {
        if is_prime(num) {
            count += 1;
            if count == n {
                return num;
            }
        }
        num += 1;
    }
}

계산기

fn calculator(a: f64, b: f64, op: char) -> Result<f64, String> {
    match op {
        '+' => Ok(a + b),
        '-' => Ok(a - b),
        '*' => Ok(a * b),
        '/' => {
            if b == 0.0 {
                Err("Division by zero".to_string())
            } else {
                Ok(a / b)
            }
        }
        _ => Err(format!("Unknown operator: {}", op)),
    }
}

fn test_calculator() {
    let operations = vec![
        (10.0, 5.0, '+'),
        (10.0, 5.0, '-'),
        (10.0, 5.0, '*'),
        (10.0, 5.0, '/'),
        (10.0, 0.0, '/'),
    ];

    for (a, b, op) in operations {
        match calculator(a, b, op) {
            Ok(result) => println!("{} {} {} = {}", a, op, b, result),
            Err(e) => println!("{} {} {} -> Error: {}", a, op, b, e),
        }
    }
}

실행 테스트

모든 예제를 실행하는 테스트 파일:

fn main() {
    println!("=== 3.1 Variables and Mutability ===");
    test_immutable();
    test_mutable();
    test_shadowing();
    test_constants();

    println!("\n=== 3.2 Data Types ===");
    test_integer_types();
    test_overflow();
    test_floating_point();
    test_tuple();
    test_array();

    println!("\n=== 3.3 Functions ===");
    test_returns();
    test_expression_vs_statement();
    test_recursion();

    println!("\n=== 3.4 Comments ===");
    // 주석 테스트는 컴파일만 확인

    println!("\n=== 3.5 Control Flow ===");
    test_if();
    test_loop();
    test_while();
    test_for();

    println!("\n=== Comprehensive Examples ===");
    fizzbuzz_match(15);
    println!("Is 17 prime? {}", is_prime(17));
    println!("Primes up to 20: {:?}", primes_up_to(20));
    test_calculator();
}

3.3 Functions & 3.5 Control Flow - 테스트 코드
Gist

참고 자료

PREFERRED_PROVIDER 로 recipe 구분하기

iosroid — Mon, 2 Sep 2024 12:46:59 +0900

Yocto에서 특정 variable의 선언여부 혹은 그 값에 따라

동일한 목적의 패키지를 제공하는 여러 recipe 중에서

다르게 선택하는 옵션을 만들어 보았다.

알고 나면 간단하지만

잘 이해하지 못했을 때는 괜한 삽질을 유도한다.

단순하게 recipe를 분리해서 동일하게 구현할 수 있겠지만

Yocto에서 제공하는 virtual target을 사용해 보았다.

https://humblenimble.hashnode.dev/experience-with-preferredprovider

PREFERRED_PROVIDER User Review

A guide on using PREFERRED_PROVIDER to implement optional source code and prebuilt package recipes in Yocto Project

humblenimble.hashnode.dev

TMUX 세션별로 환경 분리해서 사용하기

iosroid — Wed, 17 Jul 2024 22:00:55 +0900

tmux를 여러 터미널에서 동시에 다른 환경으로 사용해야 할 상황들이 있다.

간단한 예제로 개발할 때는 zsh를, 빌드할 때는 오래된 툴체인 때문에 bash를 사용해야 상황이다. (실제로)

한쪽 터미널에서는 build 를 하면서 다른 쪽 터미널에서는 develop을 계속하는 환경이 필요하다.

build 중에 종종 튕기는 악조건 이기에 어떻게든 tmux에 매달려야 한다...... (현실)

tmux.conf 파일에서 아래와 같이 수정하면 default-shell 은 간단히 수정된다.

set-option -g default-shell /bin/zsh

가끔 bash 환경을 써야 할때는 conf 파일을 따로 만들어서 사용하면 된다.

tmux -f ~/.tmux_bash.conf

zsh 환경을 가끔 쓴다면 반대로 적용하면 되겠다.

문제는 각각의 conf 옵션을 동시에 사용하려면 둘의 환경을 분리해줘야 한다.

이는 소켓의 이름을 다르게 설정하여 서버를 분리해 주는 방법으로 해결한다.

기본 소켓의 이름은 default 이다.

$ ls /tmp/tmux-1000/

default

여기서 conf 파일을 다르게 적용해도 option 들은 분리가 되지 않는다.

-L 옵션을 통해서 각각의 소켓을 만든다.

-L socket-name
tmux stores the server socket in a directory under TMUX_TMPDIR or /tmp if it is unset. The default socket is named default. This option allows a different socket name to be specified, allowing several independent tmux servers to be run. Unlike -S a full path is not necessary: the sockets are all created in a directory tmux-UID under the directory given by TMUX_TMPDIR or in /tmp. The tmux-UID directory is created by tmux and must not be world readable, writable or executable.

tmux -L devel

tmux -L build -f ~/.tmux_bash.conf

다른 이름으로 생성된 소켓을 통해 conf 환경이 분리되었다.

간단하네...

build와 devel 소켓이 생성되었다.

$ ls /tmp/tmux-1000/

build default devel

$ tmux -L devel list-sessions

0: 1 windows (created Wed Jul 17 11:21:23 2024) (attached)

$ tmux -L build list-sessions

0: 2 windows (created Wed Jul 17 11:22:00 2024) (attached)

alias로 편하게

alias tmux-dev='tmux -L devel'

alias tmux-build='tmux -L build'

tkinter와 cffi 간단한 툴 제작

iosroid — Thu, 11 Apr 2024 19:20:40 +0900

UI? tkinter와 pyqt 중 아래의 이유로 tkinter 선택

UI 복잡도가 낮아서 문서만 보고 바로 사용 가능
- 단순한 UI 요소들을 그리드 구조로 위치만 잘 잡아주면 되서 편함
- Pygubu라는 UI 제작 툴도 있음.
  - XML 파일로 UI 구조를 생성해 줌.
  - pygubu-designer로 직관적인 UI 구성 가능.
  - XML 구조가 코드로 뚝딱 뚝딱 만든 것보다 더 복잡하게 느껴져서 안 씀.
추가 설치 필요 없음.
라이센스 편함.

cffi로 c 코드 함수 사용.

처리 속도에서 우월.
처리 데이터의 양이 많을수록 확실한 차이가 남.
ctypes와 비교했고, 함수선언이 cffi 가 c 코드 그대로 사용해서 익숙해 보였음.

# cffi
my_int = ffi.new("int[1]")
my_int[0] = 5

# ctypes
my_int = ctypes.c_int(5)
my_int_ptr = ctypes.pointer(my_int)

C 함수 X() 선언.

이건 라이브러리의 헤더에 정의된 내용.

ffi.cdef("""
int x(
	uint8_t *buf,
	uint32_t *out_size,
	const uint8_t *data,
	uint32_t data_size,
	const uint8_t *p,
	uint32_t p_size,
	uint32_t t,
	uint32_t e,
	const uint8_t *u,
	uint32_t u_size
	);
""")

데이터를 넘겨받는 buf 에는 메모리 공간을 미리 할당.

out_buf = ffi.new("char[]", 512)

C의 배열 변수에 데이터를 넣듯이 파이썬 변수에도 값을 저장해 줘서 전달.

메모리 공간은 미리 할당.

파이썬 변수 dataBytes는 bytearray 타입.

data = ffi.new("uint8_t[]", len(dataBytes))
idx = 0
for d in dataBytes:
    data[idx] = d
    idx += 1

상수값이나 NULL 은 직접 값으로 전달 가능.

result = mylib.x(
        out_buf,
        out_size,
        data,
        len(dataBytes),
        ffi.NULL,
        0,
        0x1010,
        1,
        ffi.NULL,
        0
    )

C 함수의 리턴값이 result에 저장됨.

out_buf는 cffi의 타입(cdata)이므로 unpack을 이용해 데이터를 파이썬 변수로 저장해야 함.

outBufUnpack = ffi.unpack(out_buf, out_size[0])

out_size는 out_buf의 크기인데 uint32_t* 타입이라 [0]로 값을 읽어올 수 있음.

ffi.new로 생성한 변수는 ffi.release로 메모리 해제함.

설명에선 아래와 같다. 예상 가능한 시점의 빠른 해제를 위해 넣어줌.

The normal Python destructor of the cdata object releases the same resources, but this allows the releasing to occur at a known time, as opposed as at an unspecified point in the future.

The 2024 MAD Landscape

iosroid — Tue, 9 Apr 2024 14:24:21 +0900

2024년 Machine Learning, AI & Data 업계 지도와 최신 트렌드에 관한 글.

원문

Full Steam Ahead: The 2024 MAD (Machine Learning, AI & Data) Landscape – Matt Turck

Full Steam Ahead: The 2024 MAD (Machine Learning, AI & Data) Landscape

This is our tenth annual landscape and “state of the union” of the data, analytics, machine learning and AI ecosystem. In 10+ years covering the space, things have never been as exciting and promising as they are today. All trends and subtrends we desc

mattturck.com

GeekNews 에서 한글로 요약 정리된 글

2024년 ML/AI/Data 업계 지도와 최신 트렌드 | GeekNews (hada.io)

2024년 ML/AI/Data 업계 지도와 최신 트렌드 | GeekNews

이미지 한장으로 정리한 2024년 MAD(ML,AI,Data) 업계 지도 및 올해의 24가지 테마 설명[Part I : Landscape]2012년 최초 버전에서는 139개 기업만 있었으나, 2024년 MAD 생태계에는 2,011개 기업이 포함됨이는 작

news.hada.io

GeekNews 페이지에서 인상적인 글귀:

2012년 최초 버전에서는 139개 기업만 있었으나, 2024년 MAD 생태계에는 2,011개 기업이 포함됨
애플리케이션 계층의 모든 기업이 이제 스스로를 "AI 기업"이라고 칭함
현재 비구조화된 데이터(ML/AI)는 주목받고 있지만, 구조화된 데이터(모던 데이터 스택 등)는 그렇지 않음
데이터 인프라 업계는 마침내 일정 수준의 통합을 경험하게 될 것임
모두가 LLM의 힘을 원하지만 자신들의(기업) 데이터로 학습된 모델을 원함
한편 새로운 세대의 AI 인프라 스타트업들이 여러 영역에서 등장하고 있음
하이프는 늘 그렇듯 여러 장점("광적 열정 없인 위대한 성취 없다", "백 가지 꽃이 피게 하라"식의 야심찬 프로젝트에 자금이 몰림)과 단점(하룻밤에 모두가 AI 전문가로 둔갑, 모든 스타트업이 AI 기업이 됨, AI 콘퍼런스/팟캐스트/뉴스레터 범람, AI 마켓맵 홍수)을 동반함
소비자 앱은 이탈률이 높음. 단순 호기심은 아니었나?
- 개인적으로나 업무상으로나 생성형 AI를 어떻게 활용해야 할지 잘 모르겠다는 사람이 많음
- 최고의 AI 전문가가 만든 제품이라도 모두 마법 같진 않을 것임
지난 18개월간 가장 흔한 질문은 이것: 우리는 결국 평준화될 제품에 엄청난 자본이 소각되는 광경을 보고 있는 걸까? 아니면 이 LLM 기업들이 새로운 AWS, Azure, GCP가 되는 걸까?
LLM 기업 입장에선 골치 아픈 사실은, 어느 LLM도 지속적인 성능 우위를 구축하지 못하는 듯 보인다는 점
기업에서는 이런 다양한 모델을 조합한 하이브리드 아키텍처로 빠르게 진화하는 중
가격이 내려가고는 있지만 대형 사유 LLM은 여전히 비싸고 지연 문제도 있어서, 사용자/고객은 점점 더 다양한 모델을 조합해 배포하게 될 것임
- 대형/소형, 상용/오픈소스, 범용/특화 모델을 필요와 예산에 맞게 조합해 사용하는 추세임
ChatGPT의 등장으로 그 전까지 첨단으로 여겨지던 AI 기술들이 하루아침에 "전통적 AI"로 불리게 됨
앞으로 기업들은 LLM을 어떤 작업에, 전통적 AI 모델을 어떤 작업에 사용할지, 그리고 둘을 어떻게 결합할지 고민하게 될 것임
스타트업 생태계 참여자 입장에서는 GPT-5의 성능이 GPT-4 대비 얼마나 향상될지가 기술 발전 속도의 바로미터가 될 것임
시장은 자정 작용을 통해 소수의 성공적인 오픈소스 프로젝트만 클라우드 기업 등의 지원을 받게 될 것임. 그러나 그때까지는 혼란스러운 상황이 이어질 전망
공급자 입장에서는 AI 구축/서비스 비용이 여전히 높음
- Anthropic은 매출의 절반 이상을 클라우드 비용으로 지출했다고 함
- 데이터 라이선싱 비용도 만만치 않음
OpenAI가 너무 많은 걸 하려는 건 아닌가? 수직적으로나 수평적으로 AI의 모든 것을 하겠다는 것 같은데 무리수 아닌지?
OpenAI와 MS가 결별할까?

원문 작성자 mattturck 님과 GeekNews 에게 감사함을 표합니다.

python2 기본 환경에서 python3 사용하려면 feat. AI

iosroid — Tue, 12 Mar 2024 16:58:36 +0900

python2 가 기본인 시스템에서 잠시 python3 를 사용해야 할 때

구글에서 가장 흔하게 검색되었던 결과는

update-alternatives 가 많이 보였다.

얘도 결국 링크를 변경할 뿐이지만,

/usr/bin/python -> /etc/alternatives/python -> /usr/bin/python2.7

굳이 잠깐의 실행을 위해 /usr/bin 을 건들고 싶지 않은데?

조금 더 검색하면 나오는 건

virtual environment 를 사용해라 인데...

굳이 또 새로운 패키지를 설치하면서까지 필요한

그런 대단한 일도 아닌데...

shebang 을 바꿔라.

이건 python2/3 문법이 달라 나오는 에러는 그 자체로 분노유발...

등잔밑이 어둡다의 경우인지

너무 쉽고 당연하다고 생각해서 잊고 지낸 대가인지

shell 에는 alias 가 있다... 하하.

alias python=python3

이걸 두고 뭔 짓을 해온 것인가?

그런데 이걸 MS copilot 이 딴 거 다 제쳐두고 딱 이것만 답변을 해주었다.

와우..

군더더기 없고 확실하게 답을 주다니..

질문을 잘한 건가? 싶어 다른 애들에게도 물어보니

ChatGPT는 한글로 물어보니 'python3' 명령어를 쓰세요..

virtualenv 또는 venv를 사용하세요.

영어로 물어보니 위에서 말한 세 가지 방법을 다 나열해 준다.

비영어권에겐 좀 불친절...

Perplexity는 update-alternatives 만 추천.

mistral.ai 는 python3 명령어를 알려주고...

결국 다 맞는 답이긴 하지만

비록 우연일지라도 바로 내가 필요한 답을 준 Copilot에게 칭찬.

ubuntu 20.04 watchdog bug soft lockup stuck for CPU

iosroid — Wed, 22 Feb 2023 11:57:54 +0900

System:Virtualbox Guest Ubuntu 20.04

Lot of system reports poped up after log-in.

Message contains the words watchdog, soft lockup, stuck for CPU something something...

"systemd-logind crashed with sigabrt in epoll_wait()"

Host cpu usage goes high, Guest OS no response.

Not happen in Ubuntu 18.04.

Tried first.

[리눅스] watchdog: BUG: soft lockup - CPU#0 stuck for 63s! (sangchul.kr)

[리눅스] watchdog: BUG: soft lockup - CPU#0 stuck for 63s!

watchdog: BUG: soft lockup 에러 테스트 환경 $ cat /etc/os-release PRETTY_NAME="Ubuntu 22.04.1 LTS" NAME="Ubuntu" VERSION_ID="22.04" VERSION="22.04.1 LTS (Jammy Jellyfish)" VERSION_CODENAME=jammy ID=ubuntu ID_LIKE=debian HOME_URL="https://www.ubuntu.

sangchul.kr

Nothing changed

Tried second.

https://github.com/systemd/systemd/issues/9431#issuecomment-412195708

[Ubuntu 18.04] systemd-logind crashed with SIGABRT in __libc_connect() · Issue #9431 · systemd/systemd

systemd version the issue has been seen with v237 https://launchpad.net/ubuntu/+source/systemd/237-3ubuntu10 Used distribution Ubuntu 18.04 Ubuntu bug: https://bugs.launchpad.net/ubuntu/+source/sys...

github.com

It worked for me.

Another solution.

[리눅스 우분투] 시스템 프로그램 오류 (watchdog: BUG: soft lockup) 해결하기 (Linux ubuntu) (tistory.com)

[리눅스 우분투] 시스템 프로그램 오류 (watchdog: BUG: soft lockup) 해결하기 (Linux ubuntu)

안녕하세요, 오늘은 리눅스 우분투에서 시스템 프로그램 오류를 해결하는 방법에 대해 포스팅 해보도록 하겠습니다. 우분투를 시작할 때마다 아래와 같은 팝업 메시지 때문에 골치 아팠던 적이

mryeo.tistory.com

기존 리눅스 명령어 대체 툴

iosroid — Tue, 10 Jan 2023 19:00:39 +0900

[Modern Linux] 모던 리눅스 - 최신식 리눅스 명령어 모음 (tistory.com)

[Modern Linux] 모던 리눅스 - 최신식 리눅스 명령어 모음

모던 리눅스/유닉스 명령어 대부분의 리눅스 강의나 수업에서는 초창기부터 있던 전통적인 CLI 명령어(ls, cd, pwd, cat, cp, mv, rm, mkdir, ...등) 위주로 알려준다. 그러나 이 오래된 명령어들은 작성된

inpa.tistory.com

좋은 블로그 내용.

모르는게 훨씬 많다.

Rust 가 만들어 내는 변화인가.

궁금해지는 언어.

소개된 프로그램 리스트

exa (https://github.com/ogham/exa) - ls
bat (https://github.com/sharkdp/bat) - cat
fd (https://github.com/sharkdp/fd) - find
ripgrep (https://github.com/BurntSushi/ripgrep) - grep
delta (https://github.com/dandavison/delta) - more/less/diff
tldr (https://github.com/tldr-pages/tldr) - man
zoxide (https://github.com/ajeetdsouza/zoxide) - cd
Broot (https://github.com/Canop/broot) - tree
fzf (https://github.com/junegunn/fzf)
gtop (https://github.com/aksakalli/gtop)
bottom (https://github.com/ClementTsang/bottom)
dust (https://github.com/bootandy/dust) - du
duf (https://github.com/muesli/duf) - df
procs (https://github.com/dalance/procs) - ps
gping (https://github.com/orf/gping) - ping
mcfly (https://github.com/cantino/mcfly) - history
hexyl (https://github.com/sharkdp/hexyl) - od
jq (https://github.com/stedolan/jq) - sed
fx (https://github.com/antonmedv/fx) - sed
httpie (https://github.com/httpie/httpie) - curl
xh (https://github.com/ducaale/xh) - curl
dog (https://github.com/ogham/dog) - dig
nnn (https://github.com/jarun/nnn)

fzf + fd + vim plugin 은 필수조합...

조용한 담장

Rust Using Structs to Structure Related Data - Quick Reference

5. Using Structs to Structure Related Data

5.1. Defining and Instantiating Structs

핵심 개념 및 코드 스니핏

통합 실전 예제

5.2. An Example Program Using Structs

핵심 개념 및 코드 스니핏

통합 실전 예제

5.3. Methods

핵심 개념 및 코드 스니핏

통합 실전 예제

Rust Understanding Ownership - Quick Reference

4. Understanding Ownership

4.1. What Is Ownership?

The 3 Rules

메모리 동작: Move vs Copy

Case 1: Move (힙 데이터 - String 등)

Case 2: Copy (스택 데이터 - 정수, 불리언 등)

Case 3: Clone (깊은 복사)

4.2 References and Borrowing

참조의 규칙 (The Rules of References)

불변 참조 (&T) vs 가변 참조 (&mut T)

1. 여러 개의 불변 참조 (Read-Only)

2. 단 하나의 가변 참조 (Read-Write)

3. 불변과 가변의 혼용 불가

4.3 The Slice Type

문자열 슬라이스 (&str)

문자열 리터럴은 슬라이스다

배열 슬라이스 (&[T])

실전 팁: 함수 파라미터 설계

Rust Common Programming Concepts - Quick Reference

3. Rust Common Programming Concepts - Quick Reference

3.1 Variables and Mutability

핵심 개념

불변 변수 (기본)

가변 변수

섀도잉 (Shadowing)

섀도잉 스코프

상수 (Constants)

실전 팁

3.2 Data Types

핵심 개념

정수 타입 (Integer Types)

정수 오버플로우 처리

부동소수점 (Floating-Point Types)

불리언 (Boolean Type)

문자 (Character Type)

튜플 (Tuple Type)

튜플 활용 예제

배열 (Array Type)

배열 주의사항

배열 반복

배열 vs 벡터

타입 변환

타입 선택 가이드

3.3 Functions

핵심 개념

기본 함수 선언

함수 반환값

표현식 vs 문

세미콜론의 중요성

함수 매개변수 패턴

다중 반환값

재귀 함수

함수 설계 팁

3.4 Comments

핵심 개념

일반 주석

문서 주석 - 외부

문서 주석 - 내부

문서 주석 섹션들

주석 작성 팁

3.5 Control Flow

핵심 개념

if 표현식

if를 이용한 패턴

loop - 무한 루프

while 루프

for 루프

불변 참조 (`&T`) vs 가변 참조 (`&mut T`)

문자열 슬라이스 (`&str`)

배열 슬라이스 (`&[T]`)