Write and run your very first Emojicode program!

Hello World

Our own code can quickly become difficult to understand when we return to it—sometimes only a few hours later! For this reason, it’s often useful to leave a note or reminder in our code for our future selves or other developers. 

In order to tell the computer that some of the text in our program is only meant for notes (and shouldn't be executed), we can designate parts of our code as _comments_. Comments can explain what the code is doing, leave instructions for developers using the code, or add any other useful annotations.

There are two types of code comments in Emojicode: 

A _single line comment_ will comment out a single line and is denoted by `💭` preceding it:

```
💭 Prints "hi"
😀 🔤hi🔤❗️
```

A `💭` comments out any code that follows it (until the end of the line), so you can also use one after a line of code:

```
😀 🔤hi🔤❗️ 💭 Prints "hi"
```

A _multiline comment_ will comment out multiple lines and is denoted by `💭🔜` to begin the comment, and `🔚💭` to end the comment:

```
💭🔜 This is all commented out.
None of this is going to run! 🔚💭
```

Let's try writing two comments.

Comments

In everyday conversation, "data" can mean a lot of things… In programming, however, data means something very specific: pieces of information categorized into specific _types_.

In the previous exercise, we briefly met one of these data types: strings! _Strings_ are words or pieces of text that the computer treats as a single item. A string is a sequence of characters. It can be any length and contain any letters, numbers, symbols, or spaces surrounded by `🔤`'s.

Here are four different examples of strings:

```bash
🔤This is a string!🔤
🔤This is also a string!!!🔤
🔤1337🔤
🔤👆👍🔤
```

It's important to distinguish between strings and the rest of the code in our programs. Every part of a program is made up of characters, but strings are the parts we intend to keep as data—not as instructions to be executed by the computer. 

We'll meet more data types in a later lesson, but for now, let's really get to know strings. 


Strings

As the old saying goes: "If a program runs on your computer... but it doesn't generate any output... did it really run?" 🤔 Well, probably! But displaying output is still super important. 

In this course, we will often want to see the results of our labor with messages and data printed to the _console_, or _terminal_. 

To print in Emojicode, we use the `😀` `❗️` method. Let's look at an example:
```
😀 🔤Hello, World!🔤❗️
```

The code above prints `Hello, World!` to the terminal. 
+ `🔤Hello, World!🔤` is a string (we'll learn more about strings in the next exercise). It holds the message we want to print to the terminal. 
+ We wrap the thing we want to print with a `😀` at the start and a `❗️` at the end. 

Let's practice some printing.

Print

Woohoo! We have written a few basic Emojicode programs. 🙌

```
🏁 🍇
  😀 🔤Congratulations!🔤❗️
🍉
```

In this lesson, we have learned:

- The `🏁` block contains the code that should run when the file is executed. 
- The `🍇` begins a code block and `🍉` ends it.
- The `😀` `❗️` method can be used to print a message.
- Strings can be created using two `🔤`’s.
- Error messages and what they mean.
- Single line comments can be created using a `💭`.
- Multiline comments can be created using `💭🔜` and `🔚💭`.

Review

We write Emojicode programs in files with the extension **.emojic** or **.🍇**. Here in the code editor, we have a file named **hello.emojic**. It will also work if it's named **hello.🍇**.

Almost all the code in an Emojicode program will live inside a `🏁` block. A _block_ is a collection of code. The `🏁` block indicates all the code that should run when the file is executed. 

Within our larger program, we can indicate one or more blocks of code with `🍇` `🍉` code blocks:

- `🍇` to indicate the start of the code block 
- `🍉` to indicate the end of the code block

So a basic Emojicode file will have the following structure:

```pseudo
🏁 🍇
  Some code goes here
  More code goes here
🍉
```

Let's see some Emojicode in action!

The 🏁 Block

It's easy to make mistakes while programming! We all do it—[learn to love it!](https://news.codecademy.com/errors-in-code-think-differently/) When we run our code, a piece of software called a compiler tries to translate our code into machine code (code a computer understands). When the compiler gets to a piece of code that it can’t interpret, it throws an error showing where it stopped and why.  

You may recognize this as the scary red text that sometimes shows up in the terminal. 

Here's an example of an Emojicode error: 

```error
example.emojic:3:0: 🚨 error: Unexpected end of program.
```

Let's walk through the error together:
+ `example.emojic` refers to the file we're running. 
+ The `3` refers to the line of code that caused the problem. 
+ The `0` refers to the specific character within that line.
+ `🚨 error` well... that tells us it's an error! 
+ Finally, `Unexpected end of program` is the specific issue.

Oh... whoops. We figured out why our code wasn't working—we left off the closing `🍉`. Thanks, error!

Unfortunately, not every error message is so helpful. When we see an error in our terminal, we should first check to see if it points us directly to the broken code. If not, we should assume we made a _syntax error_, a typo or mistake in our code that prevents it from compiling. 

Errors

Happy World Emoji Day 2020! 👋 

[Emojicode](https://www.emojicode.org) is an open-source, full-blown strongly-typed programming language consisting of emojis. What could be a better language than that?

Here's a little history from Theo Weidmann, the creator himself:

> "Some time ago, I had the idea to create a programming language entirely consisting of Emojis. You might now ask: Whatever gave you that idea? And to be honest, I’m not sure anymore myself, but I do remember that somebody sent me a message with a lot of Emojis, and I suppose my brain ultimately started parsing that as code.
>
> Creating a programming language is not only great fun but also a learning experience (think garbage collection, computer architecture, optimizations)."

Here at Codecademy, we believe that emojis have an expressive force that brings smiles and delight to our daily communication mediums, like text messages and emails. It certainly does the same when it's sprinkled in a programming language.

Together with Theo, we built this introductory course where you will learn some of the fundamental concepts of programming using this light-hearted language. 

Hopefully, it will make you look at coding in a totally new light and maybe even inspire you to create your own programming language down the road!