Learn about the LOLCODE programming language: what is it, how it's used, and why you can has cheeseburger.


Hello, LOLCODE!

LOLCODE programs are stored in files that have the file extension **.lol**. Each file is set up with at least two lines:

```lol
HAI 1.2
KTHXBYE
```

- The first line contains `HAI` and a version number. 
- The last line contains the word `KTHXBYE`. 

For example, in the above code snippet, we're using [version 1.2](https://github.com/justinmeza/lolcode-spec/blob/master/v1.2/lolcode-spec-v1.2.md) of LOLCODE.

These two lines are required as the start and end of every LOLCODE program. Any code we write will go in between these two lines.

**Note:** All LOLCODE keywords are written in uppercase.
  
---

_`HAI` is treated as cat slang for "hi."_  
_`KTHXBYE` is short for "ok thanks bye."_

Creating a Program

LOLCODE programs may create output messages to the user with the `VISIBLE` command. We can use it to print a text message by putting `"` double quotes on each side of the message.

This code, for example, will print `"Hai World!"`:

```lol
VISIBLE "Hai World!"
```

Let's print your name onto the screen!

Printing

Woohoo! We have written our first LOLCODE programs. 🙀

In this lesson, we have learned:

LOLCODE is an esoteric programming language and each program is set up with these two lines:

```lolcode
HAI 1.2
KTHXBYE
```

- `VISIBLE` is the keyword to print.
- `I HAS A` is the keyword to declare a variable.
- `ITZ` is the keyword to intialize a variable.
- `BTW` is the keyword to create a single line comment.
- `OBTW` and `TLDR` are the keywords to create a multi-line comment.
- `GIMMEH` is how to get user input.

Review

The internet wouldn't be quite the same without letting people voice their opinions! LOLCODE programs allow the user to place their own text into a variable using a command called `GIMMEH`. 

`GIMMEH` informs the program to let the user type some input in, then hit <kbd>enter</kbd>. It'll store that input into a variable.

To use it, we'll want to first declare a variable without a value:

```lol
I HAS A opinion
```

Then use `GIMMEH` with the name of that variable:

```lol
GIMMEH opinion
```

---

_`GIMMEH` means "give me."_

User Input

As with other programming languages, we can leave little notes for ourselves in our code, referred to as comments. *Comments* are often used to provide some additional context for what's going on.

Lines that start with `BTW` are ignored by LOLCODE. We can put whatever messages we'd like in there as comments:

```lol
BTW Creating a message
I HAS A message ITZ "Me want catnip."
```

We can also place comments after other code in the same line:

```lol
VISIBLE message BTW Print the message
```

---

_`BTW` is short for for "by the way."_

Comments

Very long comments that span across many lines may be printed using the `OBTW` keyword. These *multi-line comments* will span until the first `TLDR`:

```lol
OBTW
What a
long comment
zzz
TLDR
```

When we have many lines of comments, it can be tiresome to always prefix them with `BTW`. `OBTW` comments save us time there.

As with `BTW` comments, everything inside `OBTW` comments is ignored.

---

_`OBTW` is an emphatic shorthand for "oh, btw."_  
_`TLDR` is an acronym for "too long; didn't read."_

Multi-line Comments

Collage of various cats with LOLCAT-style captions.

**[LOLCODE](https://lolcode.org)** is an esoteric programming language, meaning its purpose is to be entertaining or educational rather than useful. The language was invented in 2007 by a researcher named Adam Lindsay as a response to the then-new "LOLCAT" internet memes. 🐱

This is a real programming language with catchphrases like `I CAN HAS` and `KTHXBYE` in place of traditional programming keywords.

Let's get started!

**Fun fact:** The stars of the lolcat memes (shown on the right) are some of Codecademy team members' furry friends!

Introduction

It can be useful to store a value and use it later. This is called a _variable_ in many programming languages and can be very useful when we want to use something multiple times. 

LOLCODE's variables work similarly to variables in other languages. They have similar naming restrictions and need to be declared before they're used:

```lol
I HAS A [variable] ITZ [value]
```

- `I HAS A` and the variable name (declaration)
- `ITZ` and the value to store (initialization)

For example, to declare a `message` variable and give it a string value:

```lol
I HAS A message ITZ "Ceiling cat is watching you!"
```

And suppose we want to print the message multiple times, instead of copy & pasting it repeatedly, we could simply do:

```lol
VISIBLE message
VISIBLE message
```

---

_`I HAS A` is the lolspeak version of "I have a."_  
_`ITZ` is the lolspeak version of "it's."_