프로젝트에서 보기 →

Rust 강의 목차

시작일
종료일
수정일

Part 1: Rust 시작하기 및 기초 문법 (Step 1 ~ 10)

  1. Rust 소개: 왜 Rust인가? (안전성과 성능)
  2. 개발 환경 구축: rustup, 툴체인, 에디터 설정
  3. 첫 번째 프로그램: "Hello, World!" 작성 및 분석
  4. Cargo 기초: 프로젝트 생성, 빌드, 실행 (new, build, run)
  5. Cargo.toml 구조와 패키지 관리 이해하기
  6. 변수와 가변성: let과 mut 키워드
  7. 스칼라 데이터 타입: 정수, 부동소수점, 불리언, 문자
  8. 컴파운드 데이터 타입: 튜플(Tuple)과 배열(Array)
  9. 함수 선언, 매개변수, 그리고 반환값
  10. 코드 문서화: 주석 작성법과 rustdoc

Part 2: 제어 흐름과 미니 프로젝트 (Step 11 ~ 20)

  1. 제어 흐름 1: if 표현식
  2. 제어 흐름 2: loop 반복문과 값 반환
  3. 제어 흐름 3: while 반복문
  4. 제어 흐름 4: for 반복문과 컬렉션 순회
  5. 변수 섀도잉 (Shadowing) 기법
  6. 상수(const)와 스태틱(static) 변수
  7. 기본 연산자와 표현식(Expressions)
  8. 표준 라이브러리(std::io)를 이용한 사용자 입력 받기
  9. 미니 프로젝트 1: 숫자 맞추기 게임 만들기 (CLI 기초)
  10. 외부 크레이트(Crate) 추가 및 사용법 (rand 크레이트)

Part 3: 소유권(Ownership)과 메모리 관리 (Step 21 ~ 30)

  1. 메모리 구조: 스택(Stack)과 힙(Heap)의 이해
  2. Rust의 핵심: 소유권(Ownership) 3대 규칙
  3. 변수 데이터 상호작용: 이동(Move)의 개념
  4. 변수 데이터 상호작용: 복제(Clone)와 복사(Copy)
  5. 소유권과 함수의 관계
  6. 반환값과 소유권의 이동
  7. 참조(References)와 대여(Borrowing)
  8. 가변 참조자(Mutable References)와 데이터 경쟁 방지 규칙
  9. 댕글링 참조(Dangling References)와 컴파일러의 보호
  10. 슬라이스(Slice) 타입: 문자열 슬라이스와 배열 슬라이스

Part 4: 구조체(Struct)와 열거형(Enum) (Step 31 ~ 40)

  1. 구조체(Struct) 정의 및 인스턴스화
  2. 튜플 구조체와 유닛(Unit-like) 구조체
  3. 구조체의 데이터 소유권 및 생명주기 기초
  4. 메서드(Method) 정의 구문 (impl 블록)
  5. 연관 함수(Associated Functions)와 생성자 패턴
  6. 열거형(Enum) 정의와 활용
  7. Option 열거형: Null 없는 프로그래밍의 핵심
  8. match 제어 흐름 연산자 기초
  9. match를 활용한 Option<T> 패턴 매칭
  10. if let을 사용한 간결한 제어 흐름

Part 5: 모듈 시스템과 가시성 (Step 41 ~ 50)

  1. 모듈 시스템 개요: 패키지(Package)와 크레이트(Crate)
  2. 모듈(Module) 정의를 통한 코드 스코프 및 그룹화
  3. 모듈 트리에서 항목을 참조하기 위한 경로(Path)
  4. pub 키워드를 이용한 가시성(Visibility) 제어
  5. super 및 self 키워드 활용
  6. 구조체, 열거형, 메서드의 가시성 세부 규칙
  7. use 키워드로 경로를 스코프 안으로 가져오기
  8. as 키워드로 임포트 항목에 새로운 이름 부여하기
  9. 모듈을 여러 파일 및 디렉터리로 분리하기
  10. Cargo 작업 공간(Workspace) 구성하기

Part 6: 표준 컬렉션과 에러 처리 (Step 51 ~ 60)

  1. 벡터(Vector) 기초: Vec<T> 생성과 요소 추가
  2. 벡터 요소 접근 및 반복 순회
  3. 텍스트 처리: String과 &str의 심층 이해
  4. 문자열 결합, 슬라이싱, 반복
  5. 해시맵(HashMap) 기초: 생성과 키-값 삽입
  6. 해시맵 값 접근, 업데이트 및 소유권
  7. 에러 처리 기초: panic! 매크로와 복구 불가능한 에러
  8. Result 열거형을 이용한 복구 가능한 에러 처리
  9. match를 활용한 세밀한 Result 매칭
  10. 에러 전파(Propagation)와 ? 연산자

Part 7: 제네릭, 트레이트, 라이프타임 (Step 61 ~ 70)

  1. 제네릭(Generics)의 개념과 코드 중복 제거
  2. 함수, 구조체, 열거형에서의 제네릭 데이터 타입
  3. 제네릭 메서드 구현 및 단형화(Monomorphization)
  4. 트레이트(Trait): 공통 동작 정의하기 (인터페이스)
  5. 특정 타입에 트레이트 구현하기
  6. 트레이트를 함수의 매개변수로 사용하기 (impl Trait, Trait Bound)
  7. 트레이트 바운드를 사용한 조건부 메서드 구현
  8. 라이프타임(Lifetimes)의 개념과 대여 검사기(Borrow Checker)
  9. 함수 시그니처에서의 라이프타임 어노테이션
  10. 구조체, 메서드, 정적('static) 라이프타임 명시

Part 8: 클로저, 반복자, 스마트 포인터 기초 (Step 71 ~ 80)

  1. 클로저(Closure) 기초: 환경을 캡처하는 익명 함수
  2. 클로저의 타입 추론과 캡처 방식 (Fn, FnMut, FnOnce)
  3. move 키워드와 클로저의 소유권 이전
  4. 반복자(Iterator) 패턴의 이해와 Iterator 트레이트
  5. 소비 어댑터(Consuming Adaptors)와 반복기(Iterator) 메서드
  6. 반복자 어댑터(Iterator Adaptors): map, filter 등 활용
  7. 루프와 반복자의 성능 차이 이해 (Zero-cost Abstraction)
  8. 스마트 포인터(Smart Pointers)란 무엇인가?
  9. Box<T>를 사용하여 힙(Heap) 공간에 데이터 할당하기
  10. Deref 트레이트를 통한 스마트 포인터 참조 역참조

Part 9: 고급 스마트 포인터와 동시성(Concurrency) (Step 81 ~ 90)

  1. Drop 트레이트와 초기화/해제 리소스 관리
  2. Rc<T>: 참조 카운팅 기반 스마트 포인터 (복수 소유권)
  3. RefCell<T>과 내부 가변성(Interior Mutability) 패턴
  4. 참조 순환(Reference Cycles) 방지와 Weak<T>
  5. 두려움 없는 동시성: 스레드(Thread) 생성과 join
  6. move 클로저를 활용한 스레드 간 데이터 이동
  7. 메시지 패싱(Message Passing): 채널(mpsc)을 통한 통신
  8. 채널을 활용한 다중 프로듀서 단일 컨슈머 패턴
  9. 공유 상태(Shared State) 동시성: Mutex<T>의 이해
  10. 다중 스레드 환경을 위한 Arc<T>와 동시성 제어

Part 10: 고급 기능 및 멀티스레드 기초 프로젝트 (Step 91 ~ 100)

  1. 마커 트레이트(Marker Traits): Send와 Sync
  2. Rust에서의 객체 지향 프로그래밍(OOP) 특성 구현
  3. 트레이트 객체(Trait Objects)를 이용한 동적 분배(Dynamic Dispatch)
  4. 고급 패턴 매칭: 다양한 위치의 패턴 (if let, while let, for)
  5. 패턴 문법 심화 (다중 매칭, 범위 매칭, 구조 분해 할당)
  6. 고급 트레이트: 연관 타입(Associated Types)과 기본 타입 매개변수
  7. 안전하지 않은 Rust (unsafe): 메모리 직접 제어
  8. 매크로(Macros) 1: 선언적 매크로 (macro_rules!) 기초
  9. 매크로(Macros) 2: 절차적 매크로(Procedural Macros) 개요
  10. 중간 프로젝트: 스레드 풀(Thread Pool)을 활용한 멀티스레드 웹 서버 구축

Part 11: 테스트, 도구 및 실무 생태계 (Step 101 ~ 110)

  1. 단위 테스트(Unit Test) 작성과 #[test] 속성
  2. 통합 테스트(Integration Test) 디렉토리 구조 및 환경 설정
  3. 테스트 에러 처리 (Result 반환) 및 should_panic 속성
  4. 코드 품질 관리: Clippy를 활용한 린팅(Linting)과 관용적 코드 작성
  5. 자동 코드 포맷팅: Rustfmt 적용 및 설정
  6. 고급 문서화: 마크다운 주석 작성 및 cargo doc으로 웹 페이지 퍼블리싱
  7. 데이터 직렬화/역직렬화의 표준: Serde 크레이트의 이해
  8. serde_json을 활용한 JSON 데이터 파싱 및 생성
  9. 우아한 에러 처리 1: Anyhow 크레이트를 활용한 어플리케이션 에러 핸들링
  10. 우아한 에러 처리 2: Thiserror 크레이트를 활용한 라이브러리 커스텀 에러 정의

Part 12: 비동기 프로그래밍(Async) 및 확장 분야 (Step 111 ~ 120)

  1. 비동기 프로그래밍의 필요성과 멀티스레딩 모델과의 차이점
  2. async와 await 키워드의 이해 및 상태 머신(State Machine)
  3. Future 트레이트와 비동기 런타임의 개념 (Rust의 런타임 분리 철학)
  4. Tokio 런타임 기초: 비동기 작업 스폰 (tokio::spawn)
  5. Tokio 심화: 비동기 I/O, 타이머, 그리고 비동기 채널 통신
  6. HTTP 클라이언트: Reqwest 크레이트를 활용한 외부 API 비동기 호출
  7. 실무 로깅 시스템 구축: Tracing 크레이트와 로그 레벨링
  8. WebAssembly (Wasm) 기초: Rust 코드를 빌드하여 브라우저에서 실행하기
  9. 외부 함수 인터페이스 (FFI): C/C++ 또는 Python과 Rust 코드 연동하기
  10. 최종 실전 프로젝트: Tokio, Reqwest, Serde를 결합한 고성능 비동기 분산 웹 크롤러(또는 API 서버) 구축
← 프로젝트에서 보기