---
# System prepended metadata

title: TINKER - Javascript Part I

---

# TINKER - Javascript Part I

**Tinker Group 19: Sihan Liu, Yajuan Wu, Manya Qi**

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](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.
```javascript=
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`?
  - Is Jimmy going to the prom with Sally?
    :::success
    Yes, the output of `maybe()` return to 'yes'
- How does this work? (Code, not relationships.)
    :::success
    1. check the value of the varaition `var definitely = maybe(yes(no));` it will firstly deals with the inner function `yes(x)` since js read code from inside to outside. `Yes()`is called with a data `no` passed in as an argument, and the `yes(no)` routine begins, and `no()` is returned as a result. 
    2. Once the `no()` result is returned, since the default sequence of the program runs from top to down, `no()` function is called with an `undefined` argument, so it returns the value `yes`. And that is the final output of the `yes(no)` function call, so the var `definitely` now can be written as `var definitely = maybe(yes);`
    3. Then the function `maybe(no)` is called with a argument `yes`, the parameter `yes` is given the value `yes`, so it returns `yes` as a result. So the answer is eventually "yes".
    4. the tricky part is that `no()` does not mean value "no", and the "no" inside `maybe(no)` function is a parameter, the actual argument we give is actually `yes`. 
- When is the `no` function called?
  :::success  
  When the `yes()` function runs to an end and return the result `no()`, the `no` function is called.
- On the line `var definitely = maybe(yes(no));` there aren't ()s immediately after `no`. What is the significance of this?
    :::success
    I think the significance is that no matter what you put into the `()`, even there is no argument in the `()`, the function can still give you the string 'yes'.
- 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
    :::success
    First, when the `function yes(x)` is called, the variable value of `definitely = maybe(yes(no))` return to `no()`.
    And then `function no()` was executed and return to 'yes'. So the var now is `definitely = maybe (no())`, which equals to the output of `no()`. And finally we got the answer of yes.
    
**Template Literals** - Backtick symbols `` ` `` in JS are different than single-quotes `'` and double-quotes`"`. They are used to make what is called, `template literals`.
```javascript
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?
    :::success
    This format is another way to type out a string making use of ``. It can be used as a replacement for `"+ +"` to introduce a new string but keep the codes cleaner.
- Why are template literals super useful for us?
    :::success
    Sometimes it can be confusing and diffuclt to distinguish `"", ''` with js syntax and punctuatuion mark of a sentence. The template literals is a good thing to make the code looks clear and cleaner to read.
    Also, the use of `${}` allows variables, mathematical expressions and other placeholders in the synthetic strings, which gives the program more flexibility (so-called `string interpolation`).

### 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?
  <br>
  :::success
  The code of the simple version in HTML is less and easier to find classes and id than the bootstrap one. Since the javascript was built based on the action that we want to trigger in the webpage, I think the simple one is easier to locate relevant javascript functions.
- 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?
        :::success
        The `prompt` function will deliver results according to the way users respond to the dialog box. If users follow the guidance and type in the dialogue box and click OK, the function will return a string back to where it was called.
        ![](https://i.imgur.com/U96jJdx.png)
        
        If nothing is entered, and the user still clicks `OK`, an empty string is simply returned back to where the function is called. 
        ![](https://i.imgur.com/6vRBELW.png)
        
        However, if a user refuses to respond and clicks `CANCEL`, the prompt JavaScript function will return `null`.
        ![](https://i.imgur.com/lkaSIdD.png)


    - Explain what you think the `document.querySelector()` does. Talk about this in terms of the functions vocabulary presented in the Notes.
        :::success
        It is a selector to grab the first matched element of the document, empowering Javascript to read or access the page by selecting elements.
        If we add more things after that, the `document.querySelector()` can also read the `properties` of the page, including `attributes`, `values` and even `text` nodes.
    - If I told you that `document.querySelector` RETURNS something, what do you think that something is?
        :::success
        If it is just `document.querySelector()`, then it will access the according web element depending on the input argument. For instance, if we try to log the returning value of `document.querySelector('#fullName')`, we can see:
        ![](https://i.imgur.com/nx0soZK.png)
        which means the `document.querySelector()` returns the element with a certain attribute (id) named 'fullName'. Since it is the web element, the data type is then `undefined` .

  - How could you alter the `printName` function in order to print the users first and last name in the browser window tab?
       :::success
       We can add `alert("User's Full Name: " + fullName)` or `alert(fullName)` inside `fullName()` function. Like this:
       ![](https://i.imgur.com/6QmX2IU.png)


  - How would you use the `makeFullName` function to shorten the `greetUser` and `printName` code?
    :::success
    For `greetUser()`, in the printlog, we can replace `display` with `makeFullName(firstName,lastName)`, and delete the rest of the code.
    ![](https://i.imgur.com/p2NhYps.png)
    For `prinName()`, we can replace the printlog with `document.title = fullName`;
    ![](https://i.imgur.com/K14W8pB.png)




### 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.
    - What kind of events are happening in Part 2 and explain how this relates to when the handlers will run.
      :::success
        - When users type their name in the username into the form, the `document.querySelector` linked the javascript function to the action that was defined in the HTML, so the computer will know when to print the information that the users just input.
        <br>
        - After users type the name and email information, the `printLog` will "print" the information, the function is called to show the value on the webpage.
        <br>
        - For the reset part, the value that was set as `""` is to clean the previous input. The title that linked with `"userInfo"` id is assigned to default content: unknown person. The history part was also set to HTML format as `History:<br><br>`
       
    - What is `event.target`?
        :::success
        The target event property returns the element that triggered the event, it will get the element on which the event originally occurred.
    - What does the dot `.value, .textContent, .innerHTML` represent in this context?
        :::success
        - `.value` refers to an attribute of a tag in HTML.
        - `.innerHTML` is a property that used to read and access between the starting and ending tags of the element, and it also let you sets the content of the element.
        `document.querySelector('#prePartTwo').innerHTML = "History:<br><br>";` means that get the element with id of `prePartTwo` and give it new HTML content: `History:<br><br>`.
        - `.textContent` property can be used to get and set text content in the javascript. It is all text contained by an element.

    - Why does `updateEmail` have a parameter for `event` data but the other functions do not?
        :::success
        *Not sure about this*
        Because the `updateEmail` use the `event.target` in javascript to pass the event object when excecuted, so we need to define that event to let the computer know that which event we are refering to when changing the email in the form.
    - `resetInfo` is actually a little broken. Why?
        :::success
        The question is about `username`. In `resetInfo` function, it actually accesses the elements of the web page with ids called `username` and `email`, and changes their value to an empty string.
        
        ![](https://i.imgur.com/oAf4ySN.png)
        
        But the `resetInfo` function has defined two variables beforhand, named `username` and `email`, which are used in the previous functions:
        ![](https://i.imgur.com/sNpqYEx.png)
        
        Thus, when we click the button reset, everything seems to be reset to the default value, but if we click on the `PrintInfo` button, we will see the following result, indicating that the values of the `username` and `email` variable are not reset yet.
        ![](https://i.imgur.com/WTn6FD7.png)






### 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.
  - Compare and contrast the `showImageData` and `showImageViaParent` functions.
    - How do these two different functions achieve the same output?
        :::success
        The `showImageData` access the attribute by using `querySelector` to grab the id `animalImage` directly. 
        
        The `showImageViaParent` achieve the output by doing one more step in defining variables of `parentEl` and `childEl`, assigning `childEl` value of `parentEl`. Since the `animalImage` is under `animalImageParent`, when declaringg the function, javascript can know which image it was required to look for when user click the button.
        
        Both of them call the function to access the `<img>` and the link.
  - Compare and contrast the `showParentData` and `showParentViaImage` functions.
    - How do these two different functions achieve the same output?
        :::success
        First, both of them were declared by grabing the id inside the `<div>` element, so the output will show same tag.
        
        Second, the `showParentData` was declared by access the id `animalImageParent` directly with `document.querySelector`. The `showParentViaImage` defined variable by assigning the `parentElement` to this function.
        
        Since both of them link to the same element without the source link, so there is no link printed out, and the class is the same.
- 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.
        :::success
        ![](https://i.imgur.com/ZcOHAId.png)

- Play with the Show This Button button.
  - What is the value of the property `onclick` of the button?
    :::success
    `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.
        
  - Explain the differences between `select`, `checkbox`, `radio`, `textarea` with regard to how we get the input `values`.
      :::success
      I think the differences between these elements are due to the different ways to save and show the results in HTML.
      
      The `select` of the dropdown menu is the easiest since the value of users' selection can be only one from the dropdown options. For javascript, we only need to tell it which part of HTML (what is the id of that part) we want to output the value. The selected answer will be the output of `return selectEl.value`.
      
      The `checkbox` and `radio` required more steps to define which value we want javascript to print out as the final result. Instead of select the entire groups of button by `name` or `id`, We need to define variables for the boxes and radios that being checked to be selected for future output. We use `'[name="whichDrink"]:checked'` to set the value for future output.
      
  - What is the importance of the `name` attribute, especially for radio buttons?
      :::success
      `name` attribute us used to identify from data and refered to the javascript. And radio buttons with the same `name` allow only one choice within a group of buttons. In order to help javascript identify a function to the same set of radio buttons, we also need to use `name` to set function to that set of radio buttons.
      
  - Explain the significance of `e`, `banana`, `bananaEvent`, and `event`.
    - How are they the same and how are they different?
    :::success
    They are the same as they all equals to "things happened in HTML that javascript need to react to them".
    
    They are different in the "name" they are defined for different functions. It is meaningful to keep them unique because you don't want to confuse javascript when calling different fucntions or assigning values to different properties, such as `e.target.value` and `evt.target.value` are different. Another advatange I can think of is to make the code easier to read and find different functions.
    
- 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.
      :::success
      ![](https://i.imgur.com/uAsv501.jpg)
      We made this saved list that record history of previous answers.
      
      First we copy and paste the box of 'results' and change the class to `saved records`.
      Then we create new `function savedRecordToList(evt)` defined the properties of expected values, and define the `savedList=[]` as global list
      The 'if else' function is to prevent situations like nothing was typed but the save button was clicked, there may have errors of the outputs.
      Last we created the for loop of the `savedList` to print out all saved input.


---

# 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:

```javascript=
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.

```javascript=
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:

```htmlmixed=
<input type="text" onchange="updateComment(event)" />
<button onclick="postComment()">SAVE</button>
```
```javascript=
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 `{}`.

```javascript
// Function declaration and definition PATTERN

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

```javascript
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.

```javascript
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?
```javascript
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:

```javascript
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.

```javascript
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:

```javascript
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:

```javascript
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 `{}`.


```javascript
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.

```javascript
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.

```javascript
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.

```javascript=
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:

```javascript=
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:

```javascript
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.

```javascript
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:

```javascript=
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:

```javascript=+
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:
```javascript=
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:

```javascript=
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:

```javascript=
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.

```htmlmixed=
<!-- 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:
```javascript=
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:
```javascript=
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:
```javascript=
// 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:
```javascript=
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:
```javascript=
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.

```htmlmixed=
<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.
```javascript=
function printGreeting() {
  // sub-routine to print greeting
}
```

Attach handler to event. Call `printGreeting()` handler function when click event is triggered.
```htmlmixed=
<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.
```javascript=
// "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.
```htmlmixed=
<!-- 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.