Merge changes from sangwoo into master

sarojaba authored
revision ac912aa9c5934215e0ad59a4470e7bf15d10c0e5
getting-started
# 2. 시작하기(Getting Started) - 20%

이 책의 첫 번째 부분을 거치며 당신이 Rust, 그리고 연관된 연장장을 통해 여러분은 Rust와 Rust에 관련된 도구들을 챙기게 될 거에요. 먼저 우리는 Rust를 설치할 것입니다. 그 다음은 전통적인 "안녕, 세상아_Hello, World_" 프로그램이죠. 마지막으로, Rust의 빌드 시스템이자 패키지 매니저인 Cargo에 대해서 이야기할 것입니다.

# Rust 설치하기

첫 번째로먼저 Rust를 사용하기 위해선 설치를 하여Rust를 설치해야 합니다. 우선 우리가 Rust를 다운로드 하기 위해선여러분이 이 장에서 소개된 명령어들을 실행하려면 인터넷에 연결되어 있어야 합니다.

우리이 책에서는 터미널에서 사용되는 몇 개의 명령어의 시작을 `$` 를 표시하여 강조할 것입니다.
하지만 `$` 는 해당 라인이 커맨드라는 사실을 나타낼 뿐이므로 실제로 입력하지 않아도 됩니다.
우리는 인터넷에서인터넷에 존재하는 많은 튜토리얼이나 예제에서 `$` 는 보통 유저(일반적인 권한을 가진 유저) 가 실행하는 커맨드들의 앞에 표시하고, `#`은 관리자(관리자 권한을 가진 유저)를 통해 실행되어야 가 실행하는 명령어들 앞에 표시하는 관습이 있는데요, 이 책도 역시 그 관습을 따릅니다.


## 플랫폼 지원

'러스트' 는 수많은 플랫폼에서 컴파일되고, 실행될 수 있습니다. 러스트가 지원하는 플랫폼들은 크게 세 가지로 나뉠 수 있습니다.


### 단계 1

1단계 플랫폼들은 러스트 코드 빌드와 프로그램을 만들 수 있는 플랫폼입니다.

요구사항 -
- 플랫폼에서의 작동을 검증함.
- `rustlang/rust` 레퍼토리의 master branch의
쉽게 생각해서 '빌드가 가능하고 실행 가능한' 플랫폼입니다. 정확히는 아래의 요구사항을 만족하는 플랫폼입니다.

요구사항 -
- 테스트를 수행하기 위한 자동화가 되어 있음.
- `rustlang/rust` 저장소에 새로운 변경사항이 있을 때
테스트를 통과하는지 확인함.
- 플랫폼을 공식적으로 지원함.
- 해당 플랫폼에서 러스트를 빌드하고, 사용하기위한 문서가 작성돼있음.


| 타겟 플랫폼 | std |rustc|cargo| 비고 |
|-------------------------------|-----|-----|-----|----------------------------|
| `x86_64-pc-windows-msvc` | ✓ | ✓ | ✓ | 64-bit MSVC (Windows 7+) |
| `i686-pc-windows-gnu` | ✓ | ✓ | ✓ | 32-bit MinGW (Windows 7+) |
| `x86_64-pc-windows-gnu` | ✓ | ✓ | ✓ | 64-bit MinGW (Windows 7+) |
| `i686-apple-darwin` | ✓ | ✓ | ✓ | 32-bit OSX (10.7+, Lion+) |
| `x86_64-apple-darwin` | ✓ | ✓ | ✓ | 64-bit OSX (10.7+, Lion+) |
| `i686-unknown-linux-gnu` | ✓ | ✓ | ✓ | 32-bit Linux (2.6.18+) |
| `x86_64-unknown-linux-gnu` | ✓ | ✓ | ✓ | 64-bit Linux (2.6.18+) |

### Tier 2

2단계 플랫폼들은 러스트 코드를 빌드 할 수 있는 플랫폼입니다. 이 단계에 해당된 플랫폼을 위한 검증작업은 행해지지 않고, 그러므로자동화된 테스트는 수행되지 않기 때문에 이 플랫폼에서 완벽한 작동은 보장하지 못합니다.
하지만 이 플랫폼에서의 작동을 위한 당신의 노력은 언제나 환영합니다!

요구사항-
- 플랫폼에서의 작동을 검증할지도 모름
할 순 없지만 꽤 잘 작동합니다. 이 플랫폼에 대한 패치는 언제나 환영합니다!

요구사항-
- 자동화된 테스트가 있지만 실행되지는 않을 수 있음
.
- `rustlang/rust` 레퍼토리저장소의 master branch의 테스트를 통과했지만, 하지만 표준 라이브러리로만 검증함에 변경사항이 있을 때 **빌드**가 되는지 확인함. 어떤 플랫폼에서는 완벽히 작동하는 반면, 어떤 플랫폼에서는 빌드만 될 수 있음.
- 플랫폼을 공식적으로 지원함.


| 타겟 플랫폼 | std |rustc|cargo| 비고 |
|-------------------------------|-----|-----|-----|----------------------------|
| `i686-pc-windows-msvc` | ✓ | ✓ | ✓ | 32-bit MSVC (Windows 7+) |

### 3단계

3단계 플랫폼들은 러스트를 지원하나, 최신 버전이 아니고 플랫폼에서의 빌드와 검증 작업 이루어지지 않은 플랫폼들을 말합니다. 이러한 플랫폼들을 위한 러스트 빌드는개별 커뮤니티에 의해 지원 될유지되는 경우가 많기 때문에 퀄리티가 보장되지 않을 있습니다. 또한 포함 패키지들과 인스톨러 공식적으로 제공되지 않으며, 이 또한지만 커뮤니티에 의해 지원 될 수도 있습니다.

| 타겟 플랫폼 | std |rustc|cargo| 비고 |
|-------------------------------|-----|-----|-----|----------------------------|
| `x86_64-unknown-linux-musl` | ✓ | | | 64-bit Linux with MUSL |
| `arm-linux-androideabi` | ✓ | | | ARM Android |
| `i686-linux-android` | ✓ | | | 32-bit x86 Android |
| `aarch64-linux-android` | ✓ | | | ARM64 Android |
| `arm-unknown-linux-gnueabi` | ✓ | ✓ | | ARM Linux (2.6.18+) |
| `arm-unknown-linux-gnueabihf` | ✓ | ✓ | | ARM Linux (2.6.18+) |
| `aarch64-unknown-linux-gnu` | ✓ | | | ARM64 Linux (2.6.18+) |
| `mips-unknown-linux-gnu` | ✓ | | | MIPS Linux (2.6.18+) |
| `mipsel-unknown-linux-gnu` | ✓ | | | MIPS (LE) Linux (2.6.18+) |
| `powerpc-unknown-linux-gnu` | ✓ | | | PowerPC Linux (2.6.18+) |
| `i386-apple-ios` | ✓ | | | 32-bit x86 iOS |
| `x86_64-apple-ios` | ✓ | | | 64-bit x86 iOS |
| `armv7-apple-ios` | ✓ | | | ARM iOS |
| `armv7s-apple-ios` | ✓ | | | ARM iOS |
| `aarch64-apple-ios` | ✓ | | | ARM64 iOS |
| `i686-unknown-freebsd` | ✓ | ✓ | | 32-bit FreeBSD |
| `x86_64-unknown-freebsd` | ✓ | ✓ | | 64-bit FreeBSD |
| `x86_64-unknown-openbsd` | ✓ | ✓ | | 64-bit OpenBSD |
| `x86_64-unknown-netbsd` | ✓ | ✓ | | 64-bit NetBSD |
| `x86_64-unknown-bitrig` | ✓ | ✓ | | 64-bit Bitrig |
| `x86_64-unknown-dragonfly` | ✓ | ✓ | | 64-bit DragonFlyBSD |
| `x86_64-rumprun-netbsd` | ✓ | | | 64-bit NetBSD Rump Kernel |
| `i686-pc-windows-msvc` (XP) | ✓ | | | Windows XP support |
| `x86_64-pc-windows-msvc` (XP) | ✓ | | | Windows XP support |

표는 시간이 지남에 따라 계속 늘어날 것이고, 이목록은 더 추가 될 수 있고, 여기 나열된 것들만 3단계 플랫폼이란 건 아닙니다!


## 리눅스와 맥에서의 러스트 설치

당신이 리눅스 또는 맥을 쓰고 있다면, 설치를 위해 할 것은 다음의 명령어를 터미널에 입력하는 것뿐입니다.

```bash
$ curl -sSf https://static.rust-lang.org/rustup.sh | sh
```

이것은 설치 스크립트를 다운로드하여 설치를 진행하게 해줄 것입니다. 그리고 이 작업이 모두 잘 진행된다면 다음의 메시지가 나타날 것입니다.

```text
Welcome to Rust.

This script will download the Rust compiler and its package manager, Cargo, and
install them to /usr/local. You may install elsewhere by running this script
with the --prefix= option.

The installer will run under ‘sudo’ and may ask you for your password. If you do
not want the script to run ‘sudo’ then pass it the --disable-sudo flag.

You may uninstall later by running /usr/local/lib/rustlib/uninstall.sh,
or by running this script again with the --uninstall flag.

Continue? (y/N)
```

여기서 `y` (예)를 입력하고 편안히 설치를 기다리시면 됩니다.

## 윈도우에서의 러스트 설치

당신이 윈도우를 사용하고 있다면, 윈도우용 인스톨러를 받아서 사용해주세요 [installer][install-page].

[install-page]: https://www.rust-lang.org/install.html

## 러스트 제거

러스트를 제거하는 방법은 굉장히 쉽습니다. 리눅스와 맥에서 단지 언인스톨러 스크립트를 실행하기만 하면 됩니다.

```bash
$ sudo /usr/local/lib/rustlib/uninstall.sh
```

만약 당신이 윈도우의 편리한 인스톨러의 노예라면, 다시 `.msi`확장자를 가진 러스트 인스톨러를 다시 실행하여 제거 버튼을 누르면 됩니다.

## 문제 해결

러스트를 인스톨한 후 터미널을 열어 다음 명령어를 실행해 보십시오.

```bash
$ rustc --version
```

당신은 러스트의 버전과, 커밋 해쉬, 커밋 날짜를 볼 수 있어야 합니다.

그것이 성공하면 러스트는 성공적으로 인스톨 된 것입니다!

만약 당신이 윈도우를 사용하고, 위 작업이 실패했으면, 시스템 %PATH% 변수 안에 러스트 설치 경로가 들어있는지 확인하세요. 설치경로가 포함돼있지 않으면, 러스트를 설치한 폴더의 경로를 추가해주시길 바랍니다. _(어떻게 하는진 다들 아실 거라 믿습니다)_

불행하게도 윈도우 이외의 플랫폼에서 설치가 실패했다면, 도움을 받을 수 있는 곳이 있습니다. 가장 쉬운곳은 공식 [irc.mozilla.org의 #rust IRC 체널][irc] 입니다. IRC 클라이언트는 [Mibbit][mibbit] 을 사용하실 수 있습니다. 다른 곳으론, [사용자 포럼][users]과 [(우리들의 친구) Stack Overflow][stackoverflow]가 있습니다.

[irc]: irc://irc.mozilla.org/#rust
[mibbit]: http://chat.mibbit.com/?server=irc.mozilla.org&channel=%23rust
[users]: https://users.rust-lang.org/
[stackoverflow]: http://stackoverflow.com/questions/tagged/rust

러스트 인스톨러는 자동적으로 공식 문서를 로컬에 저장해줍니다. 유닉스 기반 운영체제라면 `/usr/local/share/doc/rust`에, 윈도우 기반이라면 `(러스트 인스톨 경로)/share/doc`에서 찾을 수 있습니다.

# Hello, world!

이제 러스트를 설치했으니, 간단한 첫 프로그램을 만들어 봅시다. 암묵적인 세계적 프로그래머 전통을 따라서 우리는 작고 아름다운 _(모두가 아는.)_ 'Hello, world!' 프로그램을 만들어 볼 것입니다.

이러한 작은 프로그램을 만들어보는 건 컴파일러가 잘 작동하는지 확인할 수 있습니다. 그리고 화면에 문자를 출력하는 건 가장 일반적인 것들임으로 빨리해볼수록 좋죠.

> 참고: 이 문서는 기본적으로 터미널에서 작업하는 것을 전제로 쓰여있습니다. 러스트는 러스트자체의 코딩 툴이 없습니다. 하지만 러스트를 지원하는 [SolidOak][soak]라는 IDE가 존재합니다. 그리고 커뮤니티에는 사용자들이 개발한 수많은 확장기능들이 있고, 러스트 재단에서 [수많은 에디터][various editors]들을 위한 러스트 플러그인을 제공합니다. 당신이 사용하는 IDE나 에디터들의 설정은 이제부터 진행할 튜토리얼과는 조금 다른 모양과 설정을 가지고 있을 수 있습니다. 그러니 IDE나 추가 에디터를 사용할 경우 적절히 설정을 변경해서 사용해주십시오.

[soak]: https://github.com/oakes/SolidOak
[various editors]: https://github.com/rust-lang/rust/blob/master/src/etc/CONFIGS.md

## 프로젝트 파일 생성

첫째로, 러스트 코드를 만들어 봅시다. 러스트는 당신이 어디서 코드를 만들든 볶든 우리든 상관하지 않지만, 우리들은 새로운 프로젝트 폴더를 당신의 홈디렉터리에 생성할 것을 권장합니다. 다음의 명령어들은 간단히 프로젝트 폴더를 생성하는 법을 소개합니다.

```bash
$ mkdir ~/projects
$ cd ~/projects
$ mkdir hello_world
$ cd hello_world
```

> 참고: 당신이 윈도우에서 파워셀이 아닌 명령프롬포트를 사용하고 있다면, `~`문자는 작동하지 않을 것입니다.

## 러스트 프로그램을 작성하고 실행하기

다음으로, 새로운 소스 파일을 만들고 *main.rs*로 이름을 작성해주십시오. 러스트 소스 파일은 항상 *.rs*를 확장자로 가집니다. 만약 당신의 파일 이름에 한 단어 이상 사용했다면, 스페이스 대신 밑줄문자 *_* 를 사용해주십시오. 예로, *wonderful rust language.rs* 를 *wonderful_rust_language.rs* 로 작성해주십시오.

이제 *main.rs*파일을 열어서 다음의 코드를 입력해봅시다.

```rust
fn main() {
println!("Hello, world!");
}
```

파일을 빌드하기 위해서는 터미널로 일단 돌아갑니다. 당신이 리눅스와 맥을 사용하고 있다면 다음 명령어들을 실행해주세요.

```bash
$ rustc main.rs
$ ./main
Hello, world!
```

당신의 운영체제가 윈도우라면, 위 명령어 중에서 그저 `main` 을 `main.exe`로 바꾸면 됩니다. 그리고 빌드 후에는 당신의 운영체제와 상관없이 터미널에 `Hello, world!` 가 출력될 것입니다. 이것이 성공했다면, 이 텍스트는 당신이 첫 러스트로 출력한 텍스트가 된 것입니다! 러스트의 세계로 오신 당신을 정말 환영합니다!

## 간단한 러스트 문법

지금부터, 방금 작성한 "Hello, world" 프로그램에 대해 자세하게 설명하도록 하겠습니다. 그럼 첫 줄부터 보시죠.

```rust
fn main() {

}
```

이 코드 라인들은 러스트에서의 *함수*를 정의하고 있습니다. 이 `main`함수는 특별합니다: 이 함수는 모든 러스트 프로그램의 시작점입니다. 코드의 첫 줄은 "난 이름이 `main`이고 아무 매개변수도 필요로 하지 않으며 아무것도 리턴하지 않는 함수를 정의하고 있어요" 라고 말하고 있습니다. 만약 매개변수가 있다면 소괄호 기호`(` 와 `)` 사이로 들어가면 됩니다. 그리고 우리는 이 함수에서 아무것도 리턴을 하지 않을 것이니까, 우리는 리턴타입을 통째로 생략할 수 있습니다.

또한 함수 본문은 중괄호 `{` 와 `}`로 쌓여있습니다. 러스트는 모든 함수의 몸체를 중괄호로 둘러싸는 것을 요구합니다. 함수 선언과 같은 줄에 한 칸의 스페이스를 두고 중괄호를 여는 것이 좋은 코드 스타일이라 여겨집니다.

`main()` 함수 안에서:

```rust
println!("Hello, world!");
```

This line does all of the work in this little program: it prints text to the
screen. There are a number of details that are important here. The first is
that it’s indented with four spaces, not tabs.

The second important part is the `println!()` line. This is calling a Rust
*[macro]*, which is how metaprogramming is done in Rust. If it were calling a
function instead, it would look like this: `println()` (without the !). We'll
discuss Rust macros in more detail later, but for now you just need to
know that when you see a `!` that means that you’re calling a macro instead of
a normal function.

[macro]: macros.html

Next is `"Hello, world!"` which is a *string*. Strings are a surprisingly
complicated topic in a systems programming language, and this is a *[statically
allocated]* string. We pass this string as an argument to `println!`, which
prints the string to the screen. Easy enough!

[statically allocated]: the-stack-and-the-heap.html

The line ends with a semicolon (`;`). Rust is an *[expression oriented]*
language, which means that most things are expressions, rather than statements.
The `;` indicates that this expression is over, and the next one is ready to
begin. Most lines of Rust code end with a `;`.

[expression-oriented language]: glossary.html#expression-oriented-language

## 컴파일과 실행은 다른 단계로 이루어짐

In "Writing and Running a Rust Program", we showed you how to run a newly
created program. We'll break that process down and examine each step now.

Before running a Rust program, you have to compile it. You can use the Rust
compiler by entering the `rustc` command and passing it the name of your source
file, like this:

```bash
$ rustc main.rs
```

If you come from a C or C++ background, you'll notice that this is similar to
`gcc` or `clang`. After compiling successfully, Rust should output a binary
executable, which you can see on Linux or OSX by entering the `ls` command in
your shell as follows:

```bash
$ ls
main main.rs
```

On Windows, you'd enter:

```bash
$ dir
main.exe main.rs
```

This shows we have two files: the source code, with an `.rs` extension, and the
executable (`main.exe` on Windows, `main` everywhere else). All that's left to
do from here is run the `main` or `main.exe` file, like this:

```bash
$ ./main # or main.exe on Windows
```

If *main.rs* were your "Hello, world!" program, this would print `Hello,
world!` to your terminal.

If you come from a dynamic language like Ruby, Python, or JavaScript, you may
not be used to compiling and running a program being separate steps. Rust is an
*ahead-of-time compiled* language, which means that you can compile a program,
give it to someone else, and they can run it even without Rust installed. If
you give someone a `.rb` or `.py` or `.js` file, on the other hand, they need
to have a Ruby, Python, or JavaScript implementation installed (respectively),
but you only need one command to both compile and run your program. Everything
is a tradeoff in language design.

Just compiling with `rustc` is fine for simple programs, but as your project
grows, you'll want to be able to manage all of the options your project has,
and make it easy to share your code with other people and projects. Next, I'll
introduce you to a tool called Cargo, which will help you write real-world Rust
programs.

# Hello, Cargo!

Cargo is Rust’s build system and package manager, and Rustaceans use Cargo to
manage their Rust projects. Cargo manages three things: building your code,
downloading the libraries your code depends on, and building those libraries.
We call libraries your code needs ‘dependencies’ since your code depends on
them.

The simplest Rust programs don’t have any dependencies, so right now, you'd
only use the first part of its functionality. As you write more complex Rust
programs, you’ll want to add dependencies, and if you start off using Cargo,
that will be a lot easier to do.

As the vast, vast majority of Rust projects use Cargo, we will assume that
you’re using it for the rest of the book. Cargo comes installed with Rust
itself, if you used the official installers. If you installed Rust through some
other means, you can check if you have Cargo installed by typing:

```bash
$ cargo --version
```

Into a terminal. If you see a version number, great! If you see an error like
‘`command not found`’, then you should look at the documentation for the system
in which you installed Rust, to determine if Cargo is separate.

## Cargo로 변환하기

이제 Hello World 프로그램을 Cargo로 변환 해봅시다. Cargo 프로젝트로 만들기 위해서 필요한 것들은 다음에 나열했습니다.

1. 당신의 소스를 정확한 폴더에 집어넣어 주십시오.
2. 이전에 만든 실행 파일을 지워 주십시오. _(윈도우라면 `main.exe`을, 다른 운영체제라면 `main` 을 지워 주시면 됩니다)_
3. Cargo 설정 파일을 생성합니다.

자, 시작해봅시다!

### 새로운 실행 파일과 소스 폴더를 생성하기

앞서, 터미널로 돌아가서 당신의 *hello_world* _(프로젝트 폴더)_ 폴더로 이동합니다. 그리고 다음의 명령어들을 실행합니다.

```bash
$ mkdir src
$ mv main.rs src/main.rs
$ rm main # or 'del main.exe' on Windows
```

Cargo expects your source files to live inside a *src* directory, so do that
first. This leaves the top-level project directory (in this case,
*hello_world*) for READMEs, license information, and anything else not related
to your code. In this way, using Cargo helps you keep your projects nice and
tidy. There's a place for everything, and everything is in its place.

Now, copy *main.rs* to the *src* directory, and delete the compiled file you
created with `rustc`. As usual, replace `main` with `main.exe` if you're on
Windows.

This example retains `main.rs` as the source filename because it's creating an
executable. If you wanted to make a library instead, you'd name the file
`lib.rs`. This convention is used by Cargo to successfully compile your
projects, but it can be overridden if you wish.

### 설정 파일 생성하기

Next, create a new file inside your *hello_world* directory, and call it
`Cargo.toml`.

Make sure to capitalize the `C` in `Cargo.toml`, or Cargo won't know what to do
with the configuration file.

This file is in the *[TOML]* (Tom's Obvious, Minimal Language) format. TOML is
similar to INI, but has some extra goodies, and is used as Cargo’s
configuration format.

[TOML]: https://github.com/toml-lang/toml

이 파일을 대신해서, 다음의 것들을 입력해주세요.

```toml
[package]

name = "hello_world"
version = "0.0.1"
authors = [ "Your name " ]
```

The first line, `[package]`, indicates that the following statements are
configuring a package. As we add more information to this file, we’ll add other
sections, but for now, we just have the package configuration.

The other three lines set the three bits of configuration that Cargo needs to
know to compile your program: its name, what version it is, and who wrote it.

Once you've added this information to the *Cargo.toml* file, save it to finish
creating the configuration file.

## Cargo프로젝트를 빌드하고 실행하기

With your *Cargo.toml* file in place in your project's root directory, you
should be ready to build and run your Hello World program! To do so, enter the
following commands:

```bash
$ cargo build
Compiling hello_world v0.0.1 (file:///home/yourname/projects/hello_world)
$ ./target/debug/hello_world
Hello, world!
```

모두 잘 작동했다면, `Hello, world!`라는 문자열이 당신의 터미널에 출력될 것입니다.

당신은 방금 `cargo build` 명령어로 프로젝트를 빌드했고,
빌드한 결과물은 `./target/debug/hello_world`에 있을 것입니다. 하지만 사실 빌드한 후 빌드한 결과물을 확인, 실행하는 것은 `cargo run` 명령어로 간단히 할 수 있습니다.

```bash
$ cargo run
Running `target/debug/hello_world`
Hello, world!
```

Notice that this example didn’t re-build the project. Cargo figured out that
the file hasn’t changed, and so it just ran the binary. If you'd modified your
source code, Cargo would have rebuilt the project before running it, and you
would have seen something like this:

```bash
$ cargo run
Compiling hello_world v0.0.1 (file:///home/yourname/projects/hello_world)
Running `target/debug/hello_world`
Hello, world!
```

Cargo는 자동으로 어느 프로젝트 파일이 수정되었는지 확인하고, 수정된 코드만 다시 빌드합니다.

With simple projects, Cargo doesn't bring a whole lot over just using `rustc`,
but it will become useful in future. With complex projects composed of multiple
crates, it’s much easier to let Cargo coordinate the build. With Cargo, you can
just run `cargo build`, and it should work the right way.

## 프로그램 릴리즈

When your project is finally ready for release, you can use `cargo build
--release` to compile your project with optimizations. These optimizations make
your Rust code run faster, but turning them on makes your program take longer
to compile. This is why there are two different profiles, one for development,
and one for building the final program you’ll give to a user.

Running this command also causes Cargo to create a new file called
*Cargo.lock*, which looks like this:

```toml
[root]
name = "hello_world"
version = "0.0.1"
```

Cargo uses the *Cargo.lock* file to keep track of dependencies in your
application. This is the Hello World project's *Cargo.lock* file. This project
doesn't have dependencies, so the file is a bit sparse. Realistically, you
won't ever need to touch this file yourself; just let Cargo handle it.

That’s it! If you've been following along, you should have successfully built
`hello_world` with Cargo.

Even though the project is simple, it now uses much of the real tooling you’ll
use for the rest of your Rust career. In fact, you can expect to start
virtually all Rust projects with some variation on the following commands:

```bash
$ git clone someurl.com/foo
$ cd foo
$ cargo build
```

## 무작정 따라하는 Cargo프로젝트 만들기

앞의 길고 긴 방법은 너무나도 번거롭습니다. _당신도 공감하리라 믿습니다._ 하지만 사실, 당신은 앞서 보여드린 번거롭디번거로운 과정을 매 새 프로젝트를 시작 할 때마다 하지 않아도 됩니다. Cargo는 쉽고 빠르게 당신이 정확하게 개발을 시작할 수 있도록 프로젝트 폴더를 구성해줍니다.

새 Cargo 프로젝트를 생성하려면, `cargo new`명령어를 실행하시면 됩니다.

```bash
$ cargo new hello_world --bin
```

This command passes `--bin` because the goal is to get straight to making an
executable application, as opposed to a library. Executables are often called
*binaries* (as in `/usr/bin`, if you’re on a Unix system).

Cargo has generated two files and one directory for us: a `Cargo.toml` and a
*src* directory with a *main.rs* file inside. These should look familliar,
they’re exactly what we created by hand, above.

This output is all you need to get started. First, open `Cargo.toml`. It should
look something like this:

```toml
[package]

name = "hello_world"
version = "0.1.0"
authors = ["Your Name "]
```

Cargo has populated *Cargo.toml* with reasonable defaults based on the arguments
you gave it and your `git` global configuration. You may notice that Cargo has
also initialized the `hello_world` directory as a `git` repository.

`src/main.rs`에는 다음의 코드가 작성돼 있을 것입니다:

```rust
fn main() {
println!("Hello, world!");
}
```

Cargo는 당신을 위해서 "Hello world!"를 먼저 생성해 둘 것입니다. 이제 당신이 코딩할 차례입니다!

> 참고: Cargo에 대해 더 궁금하다면, 공식 [Cargo 문서][Cargo guide]를 참고 하시면 좋습니다.

[Cargo guide]: http://doc.crates.io/guide.html

# 마치며

이 챕터는 기본적으로 당신의 러스트와 함께하는 시간이 목적입니다. 자, 이제 당신은 충분히 러스트와 함께 쉬고 대화했으니, 이젠 러스트가 말할 차례입니다.

당신은 두 가지 선택지가 있습니다. 바로 [러스트와 함께하는 새로운 프로젝트][learnrust]를 시작하거나, 처음부터 [러스트의 문법][syntax]을 배우며 입문하는 것입니다. 많은 경험자들 _(사실 거의 모든 이 문서의 독자들)_ 러스트와 함께하는 새로운 프로젝트를 선호할 것입니다. 뭐 사정 다른 사람은 다른 선택지를 선택하게 되겠죠! 뭐, 저에게 당신이 무엇을 아는지 모르는지가 중요한가요. 당신이 원하는 대로 하시면 됩니다.

[learnrust]: learn-rust.html
[syntax]: syntax-and-semantics.html