Skip to content
ccss17
Rust Memo
ccss17
Math
Paper
Computer
ProgrammerBase
security tutorial
ccss17
ccss17
Math
Math
Foundation of Math
Foundation of Math
History of Math
Formal System
Incompleteness theorem
Turing's proof
Consistency proof of Peano arithmetic
Set Theory
Set Theory
Set
Number Theory
Infinite Set
ZFC axiom system
Arithmetic Operations
Polynomials
Hyperreal Numbers
Surreal Numbers
Linear Algebra
Linear Algebra
Vector Space
Linear Transformation
Matrix Operation
Determinants
Diagonalization
Inner Product Spaces
Canonical Forms
Paper
Paper
Performance of Python runtimes on a non-numeric scientific code
The NumPy array: a structure for efficient numerical computation
Facenet (2015)
Quadruplet (2017)
BlueBorne
Computer
Computer
Nand to Tetris
Why the future doesn't need us
Rust Memo
Rust Memo
Ownership Rules
Move
Copy
함수 인자 전달
함수 반환값 전달
Reference
Mutable Reference
Slice
Struct
Method
Automatic referencing and dereferencing
Associated Functions
Enum
Enum Method
Important Enum: Option
Match
if let
Package 와 Crate
Module
Module 위계
use
Separating Modules into Different Files
Collections
Vector
String
HashMap
Error
unrecoverable error
recoverable error
Choice to recoverable or unrecoverable
Advice to error handling
dereferencing coercion
main function return type
for
Generic
Monomorphization
Trait
orphan rule (coherence)
Default Implementation
Trait as Parameter
Trait Bound
Multiple Trait Bound
where
return Trait
conditionally implement method
Lifetime
borrow checker
Generic Lifetime
Lifetime Annotation in Function
Lifetime Annotation in Struct
Lifetime Elision
Lifetime Elision Example 1
Lifetime Elision Example 2
Lifetime Annotation in Method
Static Lifetime
Example (Generic+Trait+Lifetime)
Automated Tests
Test 코드 작성
Test Function
Testing 방법
Custom Failure Message
panic test
Result Test
Controlling Test
thread-safe test
show output of test
Running subset of Test
Ignore some Tests
Test Organization
Unit test
Test Module and #[cfg(test)]
Integration test
tests Directory
Submodules in Integration test
Integration test for Binary Crate
derive attribute
I/O Project
First Try
Separation of Concerns
Extracting the Argument Parser
Grouping Values
Creating constructor for Config
Improving Error Handling
Returning a Result from new Instead of Calling panic!
Calling Config::new and Handling Errors
Extracting Logic from main
Returning Errors from the run Function
Handling Errors Returned from run in main
Splitting Code into a Library Crate
Developing the Library’s Functionality with Test-Driven Development
1) Failing Test
2) Writing Code to Pass the Test
Using the search Function in the run Function
Working with Environment Variables
1) 테스트 함수 작성
2) 테스트에 통과하도록 코드 구현
3) 구현 코드를 run 에 추가
환경변수
표준 에러 스트림
Functional Language Features: Iterators and Closures
Closures
Closure Type Inference and Annotation
Storing Closures Using Generic Parameters and the Fn Traits
Limitations of the Cacher Implementation
Capturing the Environment with Closures
Iterator
Iterator Trait
Methods that Consume the Iterator
Methods that Produce Other Iterators
Creating Our Own Iterators with the Iterator Trait
Improving Our I/O Project
More About Cargo and Crates.io
Customizing Builds with Release Profiles
Making Useful Documentation Comments
Cargo Workspaces
Smart Pointers
Box
Enabling Recursive Types with Boxes
Treating Smart Pointers Like Regular References with the Deref Trait
Following the Pointer to the Value with the Dereference Operator
Defining Our Own Smart Pointer
Implicit Deref Coercions with Functions and Methods
How Deref Coercion Interacts with Mutability
Running Code on Cleanup with the Drop Trait
Dropping a Value Early with std::mem::drop
Rc, the Reference Counted Smart Pointer
RefCell and the Interior Mutability Pattern
Interior Mutability: A Mutable Borrow to an Immutable Value
A Use Case for Interior Mutability: Mock Objects
Having Multiple Owners of Mutable Data by Combining Rc and RefCell
Reference Cycles Can Leak Memory
Concurrency
Using Message Passing to Transfer Data Between Threads
Shared-State Concurrency
Extensible Concurrenty (Sync and Send Trait)
OOP
Objects Contain Data and Behavior
Encapsulation that Hides Implementation Details
Inheritance as a Type System and as Code Sharing
Using Trait Objects That Allow for Values of Different Types(Polymorphism)
Trait Objects Perform Dynamic Dispatch
Object Safety Is Required for Trait Objects
Implementing an Object-Oriented Design Pattern
Patterns and Matching
All the Places Patterns Can Be Used
match Arms
Conditional if let Expressions
while let Conditional Loops
for Loops
let Statements
Function Parameters
Refutability: Whether a Pattern Might Fail to Match
Pattern Syntax
Matching Literals
Matching Named Variables
Multiple Patterns
Matching Ranges of Values with ..=
Destructuring to Break Apart Values
Destructuring Enums
Destructuring Structs and Tuples
_ 패턴
Ignoring an Unused Variable by Starting Its Name with _
Ignoring Remaining Parts of a Value with ..
Extra Conditionals with Match Guards
@ Bindings
Advanced Features
Unsafe Rust
Unsafe Superpowers
1. Dereferencing a Raw Pointer
2. Calling an Unsafe Function or Method
3. Access or modify a mutable static variable
4. Implement an unsafe trait
5. Access files of unions
Advanced Traits
Specifying Placeholder Types in Trait Definitions with Associated Types
Default Generic Type Parameters and Operator Overloading
Fully Qualified Syntax for Disambiguation: Calling Methods with the Same Name
Using Supertraits to Require One Trait’s Functionality Within Another Trait
Using the Newtype Pattern to Implement External Traits on External Types
Using the Newtype Pattern for Type Safety and Abstraction
Creating Type Synonyms with Type Aliases
The Never Type that Never Returns
Dynamically Sized Types and the Sized Trait
Advanced Functions and Closures
Function Pointers
Returning Closures
Macros
The Difference Between Macros and Functions
Declarative Macros with macro_rules! for General Metaprogramming
Procedural Macros for Generating Code from Attributes
How to Write a Custom derive Macro
Attribute-like macros
Function-like macros
ProgrammerBase
ProgrammerBase
README
Contents
Contents
Day 1
Day 2
Day 3
Day 4
Day 5
Docker
Coding Convention
Build System
Information
Git
VSCode
Markdown
Tmux
Vim
CLI
security tutorial
security tutorial
README
Day1 Base
Day2 Computer Principle 1
Day3 Computer Principle 2
Day4 Reversing 1
Day5 Reversing 2
Day6 Exploit 1
Day7 Exploit 2
Day8 Exploit 3
Day9 Exploit 4
Day10 Pentesting
Ownership Rules
Move
Copy
함수 인자 전달
함수 반환값 전달
Reference
Mutable Reference
Slice
Struct
Method
Automatic referencing and dereferencing
Associated Functions
Enum
Enum Method
Important Enum: Option
Match
if let
Package 와 Crate
Module
Module 위계
use
Separating Modules into Different Files
Collections
Vector
String
HashMap
Error
unrecoverable error
recoverable error
Choice to recoverable or unrecoverable
Advice to error handling
dereferencing coercion
main function return type
for
Generic
Monomorphization
Trait
orphan rule (coherence)
Default Implementation
Trait as Parameter
Trait Bound
Multiple Trait Bound
where
return Trait
conditionally implement method
Lifetime
borrow checker
Generic Lifetime
Lifetime Annotation in Function
Lifetime Annotation in Struct
Lifetime Elision
Lifetime Elision Example 1
Lifetime Elision Example 2
Lifetime Annotation in Method
Static Lifetime
Example (Generic+Trait+Lifetime)
Automated Tests
Test 코드 작성
Test Function
Testing 방법
Custom Failure Message
panic test
Result Test
Controlling Test
thread-safe test
show output of test
Running subset of Test
Ignore some Tests
Test Organization
Unit test
Test Module and #[cfg(test)]
Integration test
tests Directory
Submodules in Integration test
Integration test for Binary Crate
derive attribute
I/O Project
First Try
Separation of Concerns
Extracting the Argument Parser
Grouping Values
Creating constructor for Config
Improving Error Handling
Returning a Result from new Instead of Calling panic!
Calling Config::new and Handling Errors
Extracting Logic from main
Returning Errors from the run Function
Handling Errors Returned from run in main
Splitting Code into a Library Crate
Developing the Library’s Functionality with Test-Driven Development
1) Failing Test
2) Writing Code to Pass the Test
Using the search Function in the run Function
Working with Environment Variables
1) 테스트 함수 작성
2) 테스트에 통과하도록 코드 구현
3) 구현 코드를 run 에 추가
환경변수
표준 에러 스트림
Functional Language Features: Iterators and Closures
Closures
Closure Type Inference and Annotation
Storing Closures Using Generic Parameters and the Fn Traits
Limitations of the Cacher Implementation
Capturing the Environment with Closures
Iterator
Iterator Trait
Methods that Consume the Iterator
Methods that Produce Other Iterators
Creating Our Own Iterators with the Iterator Trait
Improving Our I/O Project
More About Cargo and Crates.io
Customizing Builds with Release Profiles
Making Useful Documentation Comments
Cargo Workspaces
Smart Pointers
Box
Enabling Recursive Types with Boxes
Treating Smart Pointers Like Regular References with the Deref Trait
Following the Pointer to the Value with the Dereference Operator
Defining Our Own Smart Pointer
Implicit Deref Coercions with Functions and Methods
How Deref Coercion Interacts with Mutability
Running Code on Cleanup with the Drop Trait
Dropping a Value Early with std::mem::drop
Rc, the Reference Counted Smart Pointer
RefCell and the Interior Mutability Pattern
Interior Mutability: A Mutable Borrow to an Immutable Value
A Use Case for Interior Mutability: Mock Objects
Having Multiple Owners of Mutable Data by Combining Rc and RefCell
Reference Cycles Can Leak Memory
Concurrency
Using Message Passing to Transfer Data Between Threads
Shared-State Concurrency
Extensible Concurrenty (Sync and Send Trait)
OOP
Objects Contain Data and Behavior
Encapsulation that Hides Implementation Details
Inheritance as a Type System and as Code Sharing
Using Trait Objects That Allow for Values of Different Types(Polymorphism)
Trait Objects Perform Dynamic Dispatch
Object Safety Is Required for Trait Objects
Implementing an Object-Oriented Design Pattern
Patterns and Matching
All the Places Patterns Can Be Used
match Arms
Conditional if let Expressions
while let Conditional Loops
for Loops
let Statements
Function Parameters
Refutability: Whether a Pattern Might Fail to Match
Pattern Syntax
Matching Literals
Matching Named Variables
Multiple Patterns
Matching Ranges of Values with ..=
Destructuring to Break Apart Values
Destructuring Enums
Destructuring Structs and Tuples
_ 패턴
Ignoring an Unused Variable by Starting Its Name with _
Ignoring Remaining Parts of a Value with ..
Extra Conditionals with Match Guards
@ Bindings
Advanced Features
Unsafe Rust
Unsafe Superpowers
1. Dereferencing a Raw Pointer
2. Calling an Unsafe Function or Method
3. Access or modify a mutable static variable
4. Implement an unsafe trait
5. Access files of unions
Advanced Traits
Specifying Placeholder Types in Trait Definitions with Associated Types
Default Generic Type Parameters and Operator Overloading
Fully Qualified Syntax for Disambiguation: Calling Methods with the Same Name
Using Supertraits to Require One Trait’s Functionality Within Another Trait
Using the Newtype Pattern to Implement External Traits on External Types
Using the Newtype Pattern for Type Safety and Abstraction
Creating Type Synonyms with Type Aliases
The Never Type that Never Returns
Dynamically Sized Types and the Sized Trait
Advanced Functions and Closures
Function Pointers
Returning Closures
Macros
The Difference Between Macros and Functions
Declarative Macros with macro_rules! for General Metaprogramming
Procedural Macros for Generating Code from Attributes
How to Write a Custom derive Macro
Attribute-like macros
Function-like macros
Redirect to Netlify
Back to top