---
tags: mstu5003, tinker, js
---
# TINKER - Javascript Part I

See demonstration: https://codepen.io/jmk2142/pen/eGZRME

:::info
**README:**

At the bottom (after the tinker activities) there is a [**NOTES**](#NOTES) section with a text-based conceptual explanation of many of the things going on here. My recommendation:

- Play with the interface to get a sense of what it does.
- Look at the Tinker Tasks and code first to get a sense of the context.
- Read the NOTES as it will arm you with ideas to approach the tinker task/problems.
- Then try the tinker problems.
:::

## Tinker Tasks

This tinker takes the basics of what you learned about variables, functions, arrays, and puts it in a real context of web-pages. This is our first foray into actual user-computer interaction. As a general rule of thumb, at the very least, for every section/part you should be thinking:

> What is the STATE?
> What is the SEQUENCE?
> What is the CAUSALITY?

In your groups - try to articulate these line by line, part by part. Articulation should be _out loud_ or _in writing_. It's very important that you do this outside of your head.

### Part 0 - Warmup - [Definitely Maybe] Courtney(https://youtu.be/TDe1DqxwJoc)

> Jimmy asks, Sally... will you go to the prom with me?
> [Sally](https://youtu.be/cmpRLQZkTb8?t=1m10s) handwrites the following reply back.

function yes(x){
  return x();
}
function no(x){
  return 'yes';
}
function maybe(no){
  return no;
}
var definitely = maybe(yes(no));

**Inputs and Outputs** - Try to mentally solve the problem first (using pen and paper OKAY.) Then try it to see the actual answer. Then adjust your answer accordingly.
- What do you think is the value of `definitely`?
- **The value is "Yes"**
- Is Jimmy going to the prom with Sally?
- **Yes**
- How does this work? (Code, not relationships.)
- **Function maybe(no)return no, then we can get
var definitely =(yes(no)),since function yes(x)return x(), then
var definitely = no(x), which return 'yes'**

- When is the `no` function called?
- **Yes**
- On the line `var definitely = maybe(yes(no));` there aren't ()s immediately after `no`. What is the significance of this?
- **Becasue no is a function and will be called in the return statement in yes function beacause no is function type parameter in yes function.**
- Explain how this code snippet works, line by line, part by part.
- Be very specific
- Use important keywords
- Provide explanation of what each syntax detail represents as well

- **When given a function type parameter x to function yes(x),the returned value will call function x and return x().
When given a parameter x to function no(x), it return 'yes'
When given a parameter no to function maybe(no),it return the parameter no**

**Template Literals** - Backtick symbols `` ` `` in JS are different than single-quotes `'` and double-quotes`"`. They are used to make what is called, `template literals`.

var x = "bitter";
var y = "sweet";
var z = `Coffee is ${x}, Sugar is ${y}, Monday mornings are ${x}${y}.`;
var n = "Coffee is " + x + ", Sugar is " + y + ", Monday mornings are " + x + y + ".";

// z and n end up being the same values after the String is resolved.
// "Coffee is bitter, Sugar is sweet, Monday mornings are bittersweet."

- What does the `${}` syntax represent?
- It allows us to "call" a variable use its value. For example, printing `${name}` with `name = "Madeline"` will print `Madeline`.
- Why are template literals super useful for us?
- Template literals allow us to create static content (in this case it is a string) and reuse it over and over by simply altering the variables that are called in them.

### Part 1

:::info
**Parts 1-4: Breaking it Apart**

It might help to start by forking the codepen into four separate pens. And for each pen, reducing/removing all unused code, i.e. both HTML and JS for that part, so that all that remains are the functional ones for that part to work. (There is a reason why I don't do this for you...)

Reducing what is visually in front of you can greatly help you to focus on the bits that are relevant to the sub-problem at hand.

Note that `printLog()` is utilized across multiple parts.
:::

- Click on the link at the top to view the `index-simple.html` version. Compare the HTML between this version and the Bootstrap version. Compare the JS between this version and the Bootstrap version.
- How do these two versions compare with regard to helping you understand Javascript?
- The JavaScript in the Bootstrap version is essentially the same. One difference we found is that in the Bootstrap version, the JS is `document.querySelector('body');` but in the normal version it is `document.querySelector('body>div:nth-child(2) .row:last-child button');`.
- Play with the interface (each of the buttons) and observe how the program reacts. When tinkering, try changing the order in which you play with the interface. Take note of the printed _history_.
- Explain how this program works with regard to STATE, SEQUENCE, and CAUSALITY of each line, and/or specific parts of a line as appropriate. Use specific vocabulary, as demonstrated in the notes section.
- Be sure to articulate both aspects of the HTML and JS.
- What does the `prompt` function return?
- The `prompt` function is embedded within the `setName()` function. When the user clicks on the button with the `setName()` function, the `prompt` function opens up a pop up on the screen prompting them to fill in the question for that specific prompt. After first and last name are filled out, it returns

    setName called():
    firstName assigned to Madeline
    lastName assigned to Maeloa 

- Explain what you think the `document.querySelector()` does. Talk about this in terms of the functions vocabulary presented in the Notes.
- `document.querySelector()` returns the first Element within the document that matches the specified selector, or group of selectors. If no matches are found, null is returned.
- If I told you that `document.querySelector` RETURNS something, what do you think that something is?
- `querySelector` is a function that returns an element that matches a CSS query.
- How could you alter the `printName` function in order to print the users first and last name in the browser window tab?
- We can use the `prompt` function to show a window dialogue box and `document.getElementById("output").innerText` to print the input that the user gave us.
- How would you use the `makeFullName` function to shorten the `greetUser` and `printName` code?
- We can call the `makeFullName` function within `greetUser` and `printName`.

### Part 2

- Play with the interface (each of the buttons) and observe how the program reacts. When tinkering, try changing the order in which you play with the interface. Take note of the printed _history_.
- Explain how this program works with regard to STATE, SEQUENCE, and CAUSALITY of each line, and/or specific parts of a line as appropriate. Use specific vocabulary, as demonstrated in the notes section.
- Be sure to articulate both aspects of the HTML and JS.
In articulating the HTML and Javascript in the program, the program involves an enabled state where the user clicks the buttons, and an action is performed. This includes the print info button and the reset button. When a user hovers over the reset button, then the button returns as responsive as the color changes. The part 2 code format follows the correct sequence for the HTML and also the related Javascript code. The different tags play specific roles which are key for the manipulation of different features. The use of variables plays a key role; however, the execution of one variable influences the other. The application of the different concepts in web programming, then a successful result is achieved when one enters the data and the results are printed as output. The different types of events are present in HTML code and in javascript.
The part2 section displays texts in divisions, whereby the other divisions are defined inside the main section. The main section is "hello again, unknown person ."This par is referenced through an id and "div" tags. The rest of the division section is a form which does contain a number of items, including username, email, and buttons that are triggered by different events. There are a number of defined characteristics that play a key role in the definition of the working process of the form. The last part of the form is a text area defined by an id. This part is the history part which does give the entire report of the entered data by the user. However, it is triggered through the print info button.
The javascript part begins with the variable initialization and is then followed by the function definition as update username, which has its attributes. Secondly, the update email function does play a key as it ensures the state of the email is changed when the user activates it and the data input is stored. The print info function ensures that the above-entered data as username and email, are all displayed. Causality is achieved as these variables play a key role in the success of the print information button. The reset function in javascript ensures that the data is updated for a user to enter new data. The definition of the history section in javascript is to display the data in the variables.
- What kind of events are happening in Part 2 and explain how this relates to when the handlers will run.
Global events ensure the triggering of the browser's action. Window events are also used, including the onclick method. The events play a key role in the functioning of the entire program.
- What is `event.target`?
The element that caused the event is returned by the target event attribute. Unlike the currentTarget property, which always refers to the element whose event listener started the event, the target property returns the element on which the event first happened.
- What does the dot `.value, .textContent, .innerHTML` represent in this context?
In HTML, the value property is used to describe the value of the element that it is used with.
Various HTML components it has varied meanings.
The HTML textContent attribute allows the text content of the specified node and all of its descendants to be set or returned. Although this property is quite similar to nodeValue, it returns the text of every child node. The innerHTML attribute determines or returns an element's inner HTML content.
- Why does `updateEmail` have a parameter for `event` data but the other functions do not?
The update email has a parameter of event data; this is to ensure data is set to the new value and storage of the current data inserted by the users. The print info button displays the new data.
- `resetInfo` is actually a little broken. Why?
Resetinfo is broken as it revokes the data being stored in the input; this leads to data not being displayed to the user.

### Part 3

- Play with the interface (each of the buttons) and observe how the program reacts. Take note of the printed _INFO_.
- Explain how this program works with regard to STATE, SEQUENCE, and CAUSALITY of each line, and/or specific parts of a line as appropriate. Use specific vocabulary, as demonstrated in the notes section.

- Be sure to articulate both aspects of the HTML and JS.

The state is represented by the initial first and last name prompt and continues to move onto different prompts where the user has to fill in their e-mail information, their username, and their coffee preferences. Each time the user inputs their information, it updates the state of the program. Once each information is inputted, we can see how the program changes accordingly. For instance, once a user inputs their first name, a notification pops up to prompt the user to input their last name and so on. In javascript this is represented by 'Var' such as the following:

var firstName, lastName;

where when the state of the variable is filled in with the user's information the following pop-up prompt is displayed.

firstName = prompt('What is your first name?');
Thus, causing an update in how the page looks and behaves. In this case, the "History" box is filled with new information each time it is updated. In HTML, there are no <var> tag. However, the onclick functions of the buttons in HTML changes the state of the program based on the user's clicking behavior. For instance, when the user clicks "reset", the information disappears. Similarily, the user's input of information and steps influences the sequences. For instance, the user must first type their first name to proceed to the last name. If they do not, their name would be null, affecting the 'greet user' html button. Therefore, each code causes changes in the state of the program and the sequences of the program, dependent on the user's behavior and input.

- Compare and contrast the `showImageData` and `showImageViaParent` functions.
- How do these two different functions achieve the same output?
The `showImageViaParent`function displays the information for the first child of the `id = "animalImageParent"` which is in the `id="animaImage"`, thus achieving the same output.
- Compare and contrast the `showParentData` and `showParentViaImage` functions.
- How do these two different functions achieve the same output?
The `showParentViaImage` function, as above, prints the same data information of the `id ="animalImageParent"` which is shared by the `id = "animalImage"` so it has the same output.
- Play with the Change Image button.
- Can you modify the related code so that each time you pressed it, it would show 1 of 5 images, cycling through to the next image per click?
- There are several ways to solve this.

 if (document.getElementById("animalImage").src == "https://s3-us-west-2.amazonaws.com/s.cdpn.io/228274/wiggleCat.webp"){
    document.getElementByID("animalImage").src = "https://s3-us-west-2.amazonaws.com/s.cdpn.io/228274/wiggleDog.webp";
      } else {
    document.getElementByID("imgClickAndChange").src = "https://s3-us-west-2.amazonaws.com/s.cdpn.io/228274/wiggleCat.webp";
      }
    }

- Play with the Show This Button button.

- What is the value of the property `onclick` of the button?
The value is "event":

    function onclick(event) {
    showButtonData(event)
}

### Part 4 - Challenge

- Play with the interface (each of the form inputs) and observe how the program reacts. Carefully take note of what actions cause what results, in what order. **ALSO**, open up your Chrome Devtools and watch your inspect elements tool pane as you interact with this form.
- Explain how this program works with regard to STATE, SEQUENCE, and CAUSALITY of each line, and/or specific parts of a line as appropriate. Use specific vocabulary, as demonstrated in the notes section.
- Be sure to articulate both aspects of the HTML and JS.

State: State is "the particular condition that something is in at a specific time". The initial state of this program is undefined. If there is no input (or event happens), these functions will return an undefined value if they are called on the console. Once the user starts interacting with the interface and entering values, the state is defined as how the user interacted and what the user inputed.

Sequence: Sequence is "a particular order in which related events, movements, or things follow each other". In this example, the events are onclick, onkeypress, onkeyup, and onblur. These events call functions and return some results(variables, strings, or functions) and provide some feedback to the user (results section). Once the function returns, it is stopped. If no event mentioned above occur, these functions will not be called and will not provide and return anything.

-Causality: Using given logic and syntax, when programmer told the computer to do certain things, code eliminate ambiguity. After users change State and Sequence, the results and feedback are singular.
- Explain the differences between `select`, `checkbox`, `radio`, `textarea` with regard to how we get the input `values`.

All of these are HTML attributes that ask user to input. For the "Select" input, users are provided with several options. Users click one of the options to select; For the "check box" input, users click one, two or three options from all options provided; For the "radio" input, the user click again to select one of the options and in this case users cannot select both. For the "textarea" input, users click the blank space and type in something, then click to save or reset the text. So there are different functions called when we are doing different things(such as type in, delete, save, etc.)

- What is the importance of the `name` attribute, especially for radio buttons?

The name attribute is also an HTML attribute. When we set the "name" attribute, we are defining a radio input group. Because they are part of the same group, only one option can be selected. On the JS side, we could use "name" attribute to reference data and pass the value to the 'document. querySelectorAll()' function.

- Explain the significance of `e`, `banana`, `bananaEvent`, and `event`.
- How are they the same and how are they different?

All of them are parameters, but they will be assigned different values and of course, output different results.
- Try tinkering with some of these functions to produce some diffent looking, behaving results in the results pane.
- Explain what you tinkered with and what the results were.

---

# NOTES

I wasn't sure whether to include this supplementary reading as part of the Tinker or a separate document. But here it is. You can read it first, but it probably would help to at least scan through the Tinker questions so as you read this, you can think of the Tinker questions as a context and how they relate, to make sense of some of these extras I've included.

## Programming Overview

You've already "coded" things. HTML/CSS is a way to code web-documents for consuming in browsers, and style documents for declaring how style rules apply to your web-documents. You've learned that there is structure to code, hierarchy and sequence to code, syntax to code, that specific important keywords mean something in code. Now, we're going to go further and start to "program" things using these principles, and then some.

Programming is just a set of instructions (through code) to tell the computer how to execute a particular task, a series of **routines**. There is syntax involved (as defined by the Javascript language) and logic involved (how things should happen, when). This is what really makes the web so powerful - with programming, we can make things react to users, produce human-computer interactions, hopefully in joyful ways.

### How to think about programming

I've been thinking about this one a lot. And from my years of experience, I've kind of distilled it down to three things you should be thinking about with every little thing you learn about programming. Really, these are the golden questions you should ask anytime you are writing, reading, studying programs. That is:

1. What is the STATE of the program?
2. What is the SEQUENCE of the program?
3. What is the CAUSALITY of the things in the program?

That's really it. If you do the following things, pretty much you can start to break problems down into manageable parts, as well as ask the right questions when it comes to figuring out parts you don't understand.

### STATE

> the particular condition that something is in at a specific time

You can imagine that when you visit Facebook for the first time, the program is at a certain zero state. You see a splash page and some marketing to get you to sign up. This state is easy to imagine as you can visually think of the state of the program.

But what you are now trying to see as a programmer, is how the state might be defined beyond the surface of what you can see. For example, we might represent this state as the result of some code like this:

var loggedIn = cookie.authentication;

if (loggedIn === true) {
  showUserFeed();
} else {
  showSplashPage();
}

Since we're on the splash page, you can imagine that the state of the program, more specifically, the state of the variable `loggedIn` is false. If they were already logged in, you could imagine the state of the program starting with `loggedIn === true` and therefore, pushing the displayed state to the _user feed_.

Let's say that the user doesn't have an account. We could say that the state of the program is that `var user = undefined;`

Let's say the user starts filling out the signup form and each time they fill in one item, we update the state of the user:

- `user.firstName = "Santa";` State of user (firstName) updated.
- `user.lastName = "Claus";` State of user (lastName) updated.

Each time this user data is updated, we are changing the state of the program. And through these states and assignments of states we can push how the program looks and behaves. For example, if the user leaves the page and comes back, maybe we want the program state not to start back at zero, but to start where the user left off.

States are represented by variables. You set variables to save the state of a particular program. This data that represents a certain state of a program can then be used to do something about it. That is, to _cause_ an update in the way the page looks or behaves as demonstrated in the above example.

**So the takeaway**: When you are learning this stuff, each line, each routine, each little part of a routine, you should be asking yourself:

> What is the state of the variables?
> What is the state of the program?

### SEQUENCE

> a particular order in which related events, movements, or things follow each other.

We've already established how sequence can have an effect on HTML/CSS. As a matter of fact, in Javascript sequence also has an important role. In general, code runs from top to bottom, left to right. However, with programming we have the ability to make for much more sophisticated, and dynamic sequences of things to happen.

var userTopicPrefs = [];

if (userTopicPrefs.length > 0) {
  showPinboard(userTopicPrefs);
} else {
  showTopicPicker();
}

In the above code, based on the user's topic preferences we influenced the sequence of routines to happen. Since the user has no preferences (an empty array) we bypased the routine to show the pinterest like pinboard via `showPinboard()` and instead went to a "pick your topic preferences" interaction via `showTopicPicker()`.

Take a look at the following code:

<input type="text" onchange="updateComment(event)" />
<button onclick="postComment()">SAVE</button>

var comment = undefined;

function updateComment(event) {
  var inputElement = event.target;
  comment = inputElement.value;
}

function postComment() {
  // get comment data and save it to the database
}

In this example, when the text input changes value (user fills it in) the `updateComment` function is called `updateComment()`. This sets the state of the comment variable to whatever text the user wrote in the input.

The `postComment` function is called `postcomment()` when the html button is clicked. And we could get the state of the `comment` variable and send that data to the database.

We could say that the intended sequence of this is:

1. User types in text
- change event triggered
- `updateComment()` called with `event` data passed in as argument
- `updateComment` routine begins
- `inputElement` is set to the HTML input element, via `event` property of `target`
- `comment` is set to the text, via the `value` property of `inputElement`
- `updateComment` routine ends
2. User clicks on the button
- click event triggered
- `postComment()` function is called
- `postComment` routine begins
- `comment` state is the user text and sent to the database
- `postComment` routine ends

However, what if the user clicks on the **SAVE** button before they enter any text in the input?

Sequence is more than just the order in which you write your code. When a function is called will change the sequence of what routines, and sub-routines execute. When you have user interactive things (like button clicks) the sequence can change depending on when a user triggers an interactive event. Sometimes, some code might not happen at all. These are all things you need to think about very explicitly and conscientiously.

> What are the independent groups of code sequences (routines) in my program?
> How will the STATES and EVENTS affect the SEQUENCE of the program?

### CAUSALITY

You can't really mention programming without addressing causality. And in our prior work, we've been very adamant about seeing and understanding the causality of things we do. It may seem obvious, but we program things in order to cause things to happen. Mostly, it's about causing:

- Changes to the STATE of the program
- Changes to the SEQUENCE of the program

To be honest, I can't think of anything else any line of code would do. Even things like using code to GET the state of a program, is usually for the purpose of eventually changing the state of the program.

This third golden principle of programming ties the two other golden principles together. Programming is by nature, a very explicit exercise. Understanding how each part of a program, from the higher level logic to the lower level syntax, _causes_ the program to work in a certain way is the key. Each rule in programming usually is tied to a SINGULAR result. Programming has very little ambiguity in that regard. You tell the computer precisely what you need it to do in a very exact way, or it won't work. Ambiguity, is for the humans.

> What does this program routine cause?
> What does this part of the routine cause?
> What does this syntax: symbol, operation, pattern cause? (low-level)

Ask yourself questions regarding these three golden rules with each line of code you write and you should be on your way to understanding it in a more systematic manner.

## FUNCTIONS: Inputs and Outputs

Arguably, the biggest problems I see when students are learning functions are the conceptual understandings around the following things:

- Understanding a `function` _declaration_ vs. a `function` _call_.
- Understanding `function` sub-routines in the context of a larger sequence.
- Understanding the difference between _parameters_ and _arguments_ in relation to INPUTS.
- Understanding the `return` keyword in relation to OUTPUTS.

### Declaring and Calling Functions

> Declaring a function is telling the computer: "Remember this code and run it when I tell you to in the future."

> Calling a function is telling the computer: "Remember that code? Run it now."

#### Declaring

To setup a function, you have to declare a function. That's about it. There is one key giveaway that something is a function declaration. That giveaway is the keyword `function`. Also note, that when we declare a function we also define it as a block of code to run. The giveaway here is the opening and closing curly-braces `{}`.

// Function declaration and definition PATTERN

function funcName(params) {
  // sub-routine defined
}

function doSomething() { ... }

Do you see the keyword `function` above? Yep, it's a declaration. Won't execute on its own but you essentially told the computer to be ready for the future.

var doIt = function() { ... };

Do you see the keyword `function` above? Yep, it's a declaration. Won't execute on its own but you essentially told the computer to be ready for the future. This function doesn't have a name like the first example (i.e. `doSomething`). It has a reference to it, via the variable `doIt`. But it is nameless. We call this an `anonymous` function. The variable `doIt` becomes the _inferred name_. For the most part, you can treat these similarly although there are some caveats which we might discuss later.

How about this one?

doIt();

Nope. There is no `function` keyword. Here we are not declaring a function. We can assume it was already declared prior, or maybe declared as a default with the browser, which comes with a set of functions already declared and usable for us.

Let's look at a stranger example:

setInterval(function() {
  // code
}, 1000);

Do you see the keyword `function` above? Kind of?

Here there are actually two functions. The first is a function named `setInterval`, the second is an anonymous function that we happen to declare right there. Having trouble seeing these two? Let's separate them a little bit so you can see.

setInterval( ___ , 1000);

function() {
  // code
}

`setInterval` is a function given to us by default. It has already been declared somewhere by our browser. Notice there is no `function` keyword associated with it. Here we are actually _calling_ the function.

The second function is anonymous. There is no name given to it. But it is a `function` and it is being declared right there inside the _call_. Again, the key point is to see the keyword `function` and know that you are declaring a function, and that you have defined a function.

What does this do? `setInterval` is basically a timer. It accepts two parameters. The first argument must be a `function` and second is a `Number`. Basically, `setInterval` needs a `function` that will be used every X milliseconds. Thus, in this example the `function` will run every 1 second interval. Every second, internally, `setInterval` will _call_ the function you passed in. Thus, it is convenient for us to declare a function right within the `setInterval` call, giving us this funny looking but common format. We could have easily rewritten this like the following:

function moveClockSecHand() {
  // code to move the second hand of the analog clock
}
setInterval(moveClockSecHand, 1000);

It's the same as above, except we declared a named function on the lines prior, and passed that function into the `setInterval` as an argument through the reference.

#### Calling

To use a function, you have to _call_ a function. There is one key giveaway that something is a function _call_. That giveaway is that you see parentheses `()` immediately after some reference and there is no keyword `function`. The pattern to call a function is the following:

funcName();                // Without arguments

funcRef(argA, argB, ...);  // With arguments

If you see `something()` or `something(arg, arg)` or something like that you are _calling_ an already declared function. You might have declared it yourself, it might come from the default, it might come from a library like Bootstrap.

You'll also notice that we don't have curly-braces `{}` when calling a function. Makes sense since curly-braces are for blocking off and defining the code to be run. Since we've already done that, when you call a function you won't see any `{}`.

doSomething();

Do you see the keyword `function` above? Any `{}`? No. So it's not a declaration. Does it fit the pattern of `something()`? With `()` right after the function name? Yup. Thus, here we are _calling_ the function, telling the computer to execute it as it was declared and defined earlier.

doSomething("Thomas");

Does it fit the pattern of a function call? Yes. Do you see a `function` keyword or `{}`? No. Here, we are _calling_ the `doSomething` function and passing in the argument `"Thomas"` which, depending on how the function was declared - will probably do something with the input.

doSomething;

Do you see the keyword `function` above? No. So it's not a declaration. Do you see any `()` following this reference in the pattern of `something()`? No. So we are not _calling_ a function either.

Here, this is essentially a variable. Much earlier in this section, we did declare it and define it. So we can say that the variable `doSomething` just points to a function. `doSomething` is a function. But the declaration happened way earlier, and it is not being called right now.

### Thinking of Function Sequence as Sub-routines

A function is basically a block of code, a sub-routine that will execute when you _call_ upon it to do so. Take a look at the following routine.

function setName(someName) {
  myName = someName;
}

var myName = "Anonymous";

setName("George Washington");
myName = "Valentina Tereshkova";
setName("Mark Twain");

You can think of the sequence of this routine as executing top to bottom. But keep in mind that the code inside the function `setName` is a sub-routine of the larger code. That sub-routine does not actually happen until the function is called upon `setName(...)`. So the order of how this code happens is the following:

Line 1 - function is declared.
Line 5 - variable is declared and assigned a value.
Line 7 - function is called.
Line 2 - sub-routine executes.
Line 8 - variable is assigned a value.
Line 9 - function is called.
Line 2 - sub-routine executes.

### Paramters vs. Arguments as INPUT

> A parameter is a variable in a function definition.

> An argument is the data you pass into the function's parameters, when a function is called.

Here is the pattern to understand this:

var kelvin;

function celciusToKelvin(celcius) {
  kelvin = celcius + 273.15;
}

celciusToKelvin(0); // kelvin = 273.15

We declared and defined the `celciusToKelvin` function on line 3. Inside the `()`, `celcius` is the parameter, a variable name we made up.

`0` is the argument we pass into the function when we call it on line 7.

We could have defined the parameter like this:

function celciusToKelvin(c) {
  kelvin = c + 273.15;
}

celciusToKelvin(-273.15); // kelvin = 0

// OR this in honor of Hawaii's official State Fish

function celciusToKelvin(humuHumuNukuNukuApuaA) {
  kelvin = humuHumuNukuNukuApuaA + 273.15;
}

celciusToKelvin(100); // kelvin = 373.15

The computer doesn't care how we define our parameters when we declare and define our function. These variations are essentially the same as the original. What is important is that we give the parameters, variable names that makes sense; because as you can see, it is how we access the data that is passed into the function for use internally by the function.

What people tend to mess up most is that they see an example with a parameter defined a certain way. Then they think that parameter name is something special like a keyword. You might call it `celcius`, I might call it `c`. Strange people might name it after a fish. A common example that messes people up:

Finally, you can pass data in as arguments by reference of course.

var myApartmentTemp = 20;
var someTemp = myApartmentTemp;
var x = someTemp;

celciusToKelvin(x); // kelvin = 293.15

### Return as function OUTPUT

> Get data back, where the function was called.

Sometimes functions have OUTPUTS. What people confuse is output in terms of data vs. output in terms of behaviors.

For example:

function hello() {
  document.write("Hello");
}

Many people have the misconception that the output here is `"Hello"`. This may make sense from a user perspective, it is not what we mean by output from a programming perspective. For example, using the above code if I did something like the following:

var message = hello() + " World!"; // "undefined World!"

`message` would _not_ be set to `"Hello World"`.

Our `hello` function never had any data output. It probably sent data to the screen and printed "Hello" on the page somewhere. But it didn't have a functional data output.

The key point here is when we talk about functions and output, we are really talking about using the keyword `return`.

> Return data back to where the function was called.

For example:

var first = "Jean Luc";
var last = "Picard";

function makeFullName(first, last) {
  return last + ", " + first;
};

var username = makeFullName(first, last); // Picard, Jean Luc

`makeFullName` formats the name and returns a string "Picard, Jean Luc" to where it was originally called. That is, the right side of `=` operator. `username` is set to this value.

Or another:

function hello() {
  return "Hello";
}

var message = hello() + " World!"; // "Hello World!"

Our function `hello` _returns_ data back to where it was called. The way to think about the above example, line 5 is like this.

Right side looks like:

  hello() + " World!"

Evaluate the right side:
  Evaluate the function call, hello()
    returns a string "Hello"
Right side now looks like:

  "Hello" + " World!"

Continue evaluating right side:
  Concatenate "Hello" + " World!"
Right side now looks like:

  "Hello World!"

Assign the variable message to "Hello World!"

Take a look at this example:

function halfLife(materialVolume) {
  return materialVolume / 2;
}

var volume = 100;

halfLife(halfLife(halfLife(volume))); // 12.5

Since the function `halfLife` will always return a number, we can call it and use the return output number as the argument for the next call. On line 7, we do this 3 times to get 12.5.

As a rule of thumb, if you want your function to have an output, so that you can use that output to construct more sophisticated statements, use the keyword `return` and be aware of what kind of data you are returning.

## HTML and Javascript

There are a few key concepts that I want you to understand for this Tinker, with regard to how HTML and Javascript relate.

The point of Javascript, is to "connect" with HTML. That is, we basically use Javascript to manipulate our things on our HTML page. As we have learned:

- HTML is a language that represents the structure and organization of a web-based, browser readable `document`.
- It consists of things like `elements` and `text` nodes that are structured in a parent-child hierarchy.
- These things have `attributes` and `values` that further shape how these things are represented.

<!-- Within larger HTML Document -->

<div id="kittens" class="cute meow">
  <img src="images/meowth.jpg" />
  <img src="images/purrrr.jpg" />
  <p>
    I really like <span>fluffy</span> kittens.
  </p>
</div>

<!-- Pattern of HTML Nodes -->
<element attrA="valueA" attrB="valueB">
  <element attrC="valueC"/>
  <element attrD="valueD"/>
  <element>
    Text Node <element>text</element> text.
  </element>
</element>

Javascript can **_read/access_** the page by `selecting` elements:

var kittenDiv = document.querySelector('#kittens');   // An element: div#kittens
var imageElements = document.querySelectorAll('img'); // List of elements: [imgA, imgB]

Javascript can **_read/access_** `properties` of elements:

document.querySelector('#kittens').id;   // "kittens"

document.querySelectorAll('img')[0].src; // "images/meowth.jpg"
document.querySelectorAll('img')[1].src; // "images/purrrr.jpg"

Javascript can **_read/access_** other useful properties of elements:

// I'm use "el" as shorthand for "element", a common convention.
var el = document.querySelector('p');
var myText = el.textContent;  // "I really like fluffy kittens."
var myHTML = el.innerHTML;  // "I really like <span>fluffy</span> kittens."

Javascript can **_traverse_** the document structure:

var imgOne = document.querySelectorAll('img')[0]; // <img src="images/meowth.jpg" />
var imgTwo = imgEl.nextElementSibling;            // <img src="images/purrrr.jpg" />

var spanEl = document.querySelector('span');      // <span>fluffy</span>
var pEl = spanEl.parentElement;                   // <p>I really like <span>fluffy</span> kittens.</p>

Javascript can **_manipulate_** elements:

var imgOne = document.querySelectorAll('img')[0].src; // "images/meowth.jpg"
    imgOne.src = "images/nyancat.jpg";                // "images/nyancat.jpg"

var kittenEl = document.querySelector('#kittens');
var kittenClasses = kittenEl.className;               // "cute meow"
var kittenClassList = kittenEl.classList;             // ["cute", "meow"]
    kittenClassList.add("hungry");                    // ["cute", "meow", "hungry"]
    kittenClassList.remove("cute");                   // ["meow", "hungry"]
    kittenClasses = "dogWasHere";                     // className "dogWasHere", classList ["dogWasHere"]

And when you do these things, your page will dynamically change.

### Javascript Events

Javascript, also makes it possible to react to user actions. Common actions are things like:
- Clicking the mouse
- Pressing a key
- Scrolling a mouse wheel
- Pinching on mobile
- Value changes on forms

These things are called **_events_** and there is pattern to how you go about hooking up your JS to these things. That pattern is you need to:

- **_Listen_** for a specific event
- **_Trigger_** an event (often by the user actions)
- **_Handle_** what to do when the event is triggered

There are a few ways to get your page to listen for events but the one we're using for now is to use HTML markup to tell the page what to listen to.

<div onclick=""></div>
<textarea onkeypress=""></textarea>
<input onchange=""/>

This `on` `event`, rather `onevent` pattern works for many different kinds of events. What we are doing here is setting a _listener_ for that particular event on that particular element. `div` will do something when it is _clicked_. `textarea` will do something when _key is pressed_. `input` will do something when the `value` changes.

Thus, the `event` part of it is _triggered_ by the user actions.

Finally, what then happens? We need to _handle_ these events. That is, when an _event_ occurs, we need to tell it what function to call. That function is referred to as a _handler_ function. In the above example, you'll notice that the values are all empty. This is where we will tell HTML what the handler should be.

Declare the `printGreeting` function.

function printGreeting() {
  // sub-routine to print greeting
}

Attach handler to event. Call `printGreeting()` handler function when click event is triggered.

<div onclick="printGreeting()"></div>

This `onclick` attribute and `printGreeting()` value - an event handler call, is the connection between your HTML and JS.

It's worth noting here that when events happen, you might want to know something about the event in your handler function. For example, what kind of event was triggered? What key was pressed? What element was it that triggered the event? (You can have multiple elements share the same handler function).

To deal with this, you can design your handler function to accept a parameter that represents the event data. If you do this, when you call the handler you would pass in an argument representing the event data. For example:

Declare the `printGreeting` function with a parameter to accept event data.

// "e" is an arbitrary name representing the event data
function printGreeting(e) {
  e.target; // element that the event handler was attached to
  e.type;   // "click"

  e.target.innerHTML = "<strong>Hello World!</strong>";
}

Attach handler to event. Call `printGreeting(event)` handler function with `event` data passed into function when click event is triggered.

<!-- Call printGreeting and pass in event argument -->
<!-- Here you must use the exact word: event       -->
<div onclick="printGreeting(event)"></div>

I want you to study this _pattern_ and recognize where I've used this throughout this Tinker exercise. You should take the process concept: `listen`, `trigger`, `handle` and map it to your understanding of HTML and JS functions. If you can understand this pattern, you'll be able to apply it to all these interesting categories of events [Events](https://developer.mozilla.org/en-US/docs/Web/API/Event). Some of the ones you might find interesting are:
- https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent
- https://developer.mozilla.org/en-US/docs/Web/API/InputEvent
- https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent

Take a look at some of the `properties` available to you through the event argument. For example, `event.type` (I used `e.type` in the example above) is a generic property of all [Events](https://developer.mozilla.org/en-US/docs/Web/API/Event). But if you go into [MouseEvents](https://developer.mozilla.org/en-US/docs/Web/API/MouseEvent) you'll find that there are special properties for mouse events like the click coordinates X and Y. Browse through it and finding linkages between the docs and the examples provided in this exercise.