{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7cee85dc-0711-48b9-9dd1-8d5a0efa2a68",
   "metadata": {},
   "source": [
    "## Hello, World!\n",
    "Now that you’ve installed Rust, it’s time to write your first Rust program. It’s traditional when learning a new language to write a little program that prints the text Hello, world! to the screen, so we’ll do the same here!\n",
    "\n",
    "### Creating a Project Directory\n",
    "\n",
    "Open a terminal and enter the following commands to make a *projects* directory and a directory for the “Hello, world!” project within the *projects* directory.\n",
    "\n",
    "```sh\n",
    "$ mkdir ~/projects\n",
    "$ cd ~/projects\n",
    "$ mkdir hello_world\n",
    "$ cd hello_world\n",
    "```\n",
    "\n",
    "### Writing and Running a Rust Program\n",
    "\n",
    "Next, make a new source file and call it *main.rs*. Rust files always end with the *.rs* extension. If you’re using more than one word in your filename, the convention is to use an underscore to separate them. For example, use *hello_world.rs* rather than *helloworld.rs*.\n",
    "\n",
    "Now open the *main.rs* file you just created and enter the code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "23512a76-d996-4702-9a5d-51a85e478057",
   "metadata": {},
   "outputs": [],
   "source": [
    "fn main() {\n",
    "    println!(\"Hello, world!\");\n",
    "}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9934548-d9f5-4c25-b3eb-2d77d476ea78",
   "metadata": {},
   "source": [
    "To see the output in this notebook run the code below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8f6c527a-0df4-40fc-afbf-f69ec93c5f69",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, world\n"
     ]
    }
   ],
   "source": [
    "println!(\"Hello, world\");"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3635726e-d07d-4013-88c0-9eec55a4b5dd",
   "metadata": {},
   "source": [
    "To run in your terminal, just follow the steps below.\n",
    "\n",
    "```rust\n",
    "$ rustc main.rs\n",
    "$ ./main\n",
    "Hello, world!\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a99d564-5228-4814-aa7b-f5b112f5f67c",
   "metadata": {},
   "source": [
    "```rust\n",
    "$ rustc main.rs\n",
    "$ ./main\n",
    "Hello, world!\n",
    "```\n",
    "\n",
    "Regardless of your operating system, the string `Hello, world!` should print to the terminal. If `Hello, world!` did print, congratulations! You’ve officially written a Rust program. That makes you a Rust programmer—welcome!\n",
    "\n",
    "<details>\n",
    "  <summary>more details</summary>\n",
    "  \n",
    "  ### Anatomy of a Rust Program\n",
    "  Let’s review this “Hello, world!” program in detail. Here’s the first piece of the puzzle:\n",
    "  \n",
    "  ```rust\n",
    "  fn main() {\n",
    "\n",
    "  }\n",
    "  ```\n",
    "\n",
    "\n",
    "These lines define a function named main. The `main` function is special: it is always the first code that runs in every executable Rust program. Here, the first line declares a function named `main` that has no parameters and returns nothing. If there were parameters, they would go inside the parentheses `()`.\n",
    "\n",
    "The body of the main function holds the following code:\n",
    "\n",
    "```rust\n",
    "    println!(\"Hello, world!\");\n",
    "```\n",
    "\n",
    "This line does all the work in this little program: it prints text to the screen. There are four important details to notice here.\n",
    "\n",
    "First, Rust style is to indent with four spaces, not a tab.\n",
    "\n",
    "Second, `println!` calls a Rust macro. If it had called a function instead, it would be entered as `println` (without the `!`). We’ll discuss Rust macros in more detail in Chapter 19. For now, you just need to know that using a `!` means that you’re calling a macro instead of a normal function and that macros don’t always follow the same rules as functions.\n",
    "\n",
    "Third, you see the `\"Hello, world!\"` string. We pass this string as an argument to `println!`, and the string is printed to the screen.\n",
    "\n",
    "Fourth, we end the line with a semicolon (`;`), which indicates that this expression is over and the next one is ready to begin. Most lines of Rust code end with a semicolon.\n",
    "\n",
    "### Compiling and Running Are Separate Steps\n",
    "\n",
    "You’ve just run a newly created program, so let’s examine each step in the process.\n",
    "\n",
    "Before running a Rust program, you must compile it using the Rust compiler by entering the `rustc` command and passing it the name of your source file, like this:\n",
    "\n",
    "```sh\n",
    "$ rustc main.rs\n",
    "```\n",
    "\n",
    "Just compiling with `rustc` is fine for simple programs, but as your project grows, you’ll want to manage all the options and make it easy to share your code. Next, we’ll introduce you to the Cargo tool, which will help you write real-world Rust programs.\n",
    "</details>"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Rust",
   "language": "rust",
   "name": "rust"
  },
  "language_info": {
   "codemirror_mode": "rust",
   "file_extension": ".rs",
   "mimetype": "text/rust",
   "name": "Rust",
   "pygment_lexer": "rust",
   "version": ""
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}