## Wednesday, July 31, 2019

### Learning Desmos CL: Day 6

I just took another look at Andrew Knauft's tweet and I didn't even realize before now that it had a variable in it - in fact it SAYS "variable assignment". My brain doesn't register stuff until I've come around to it I guess. Variables are, I think, the secret sauce.

I'm going to try this out but first predict what it does. In this activity, a student will be prompted to enter a number in an input component (labelled input1), and once they do, a note will display the message "Your number was" followed by whatever number they input. These two lines of script go together as sink and source, which is one thing that's been sort of confusing me. I thought there always had to be two lines of script, one about each, but up till now, that hasn't always been the case.

Tried it, didn't work at first because I forgot to check the f(x) Math option in the input, now it works on screen 5 of this puppy.

So we needed a variable here because not every student will type in the same thing, but we want whatever they do type to be immediately displayed. But why didn't we need one for, say, the guess-the-slope-of-the-line activity? Was it because the slope was being sent to a graph as opposed to a note, and the graph sort of takes care of the variable part of it with the y = ax thing? And also this part of the script number("a"): which seems to be defining the variable AND the sink at the same time?

I notice that in the variable assignment, the structure is similar to a sink assignment, in that, after the equals sign, it names the component that will be the source, and its data type.

I'll continue looking at Jocelyn's collection now.  I've already looked at and blogged about the first 3-4 so far but I'll look again with new eyes. I'll also try a new strategy of looking at the preview first, then figuring out all I can about what the script must have been. Eg 1 preview:

3 components, a graph, a note, and an input. Whatever is typed into the input immediately shows up on the graph. So the source is the input and the sink is the graph. There must be script in the graph's gearbox. The script must include sinktype: note1.sourcetype. Also since the equation I typed is being displayed properly and not as y = x^2, which is what I actually typed, it must be that what I type is being interpreted as latex, so the f(x)math option must have been selected in the input, and the sourcetype must have been latex. I'm not sure what the sinktype would be. Also in the actual graph there must be something about a variable that is the name of the function being graphed?

And after checking: In the graph the function has been called f(x), so that's the variable definition. The input has been labelled input1. The script is where I expected it to be, in the graph's gearbox. The script is one line:

function("f"):simpleFunction(input1.latex)

So the sinktype was function, it includes the variable f in brackets and quotes so that it references which variable we want going into the sink, and the source type is latex. The only part that surprised me was the simpleFunction part. Why does that have to be there? And since it's after the colon, does that mean it's a sink or a source type? I expected a label to follow the colon, which there is one but not immediately after.

Back to the CL doc, where I'll look up simpleFunction (again) in the table under Graph.

I found it but only under function, and under the Sinks part. It says:

function(identifier: string)Sets the output of simpleFunction() to a variable defined in the graph.

The accompanying example is:

# Get the latex string from "equationInput" and assign# it to f in the calculator.
function("f"): simpleFunction(equationInput.latex, "x")

which is virtually identical to the one in Joce's eg except for the "x" part, which I seem to recall is something that if it's not there, is assumed.

I also looked under "Functions" and found simpleFunction. It says:

simpleFunctionTakes a latex string and returns a function which can, for example, be passed into the function sink of a calculator.The first argument is the latex string, and additional arguments are The names of the variables to treat as input variables (defaults to)one-variable function in terms of x if not specified

Aha that's where I saw the bit about the x.  Anyway, so it appears there are other pre-defined operations, like simpleFunction, that do additional things if you put them into the script. I don't know how to put this into my syntax structure from day 5. Does it always go right after the colon/equals sign? Is it a source or a sink or a datatype or something else altogether?

I really need to come up with some kind of a diagram to help me order things in the script, and I suspect others who are struggling with CL might too.

## Tuesday, July 30, 2019

### Learning CL: Day 5

It's amazing how many times I have to read, re-read, re-re-read before things start to sink in. (Haha sink get it?)

Syntax/structure I've gotten so far:
1. Label all components you intend to use as a source eg note1, exp2, table1 etc
2. Script goes in the gearbox of whichever component you want to be the sink
3. Script starts with the data type for that sink, which could be a word like content, number, function, cellContent.....etc then that is followed by a colon
4. Next you put the name of the component that you want to be the source eg exp1, note1, table2 etc, followed by a dot
5. After the dot you specify the type of data you want to extract from the source (bc it could contain more than one type of data) so that could be numericValue, content, latex, cellContent(1,2) etc
So a script starts out talking about the sink, then ends talking about the source. The script says "This is what's going here and this is where I'm getting it from."

To confirm this, I've gone through a few samples of CL from the CL doc and from Jocelyn's collection, to trace this pattern. (Some of these examples have um other stuff besides what I've listed above):

Data type of the sink at the beginning of the script, followed by a colon:

The name of the component from which something will be extracted, followed by a dot:

In the first example, what's in the quotation marks is, I guess, the source. This must mean that no matter what happens, Hello! I'm the computation layer! is what will be displayed. Similar to the third example, in which the variables m and b will only ever take on the values 1.5 and 2.

Finally, the type of data being extracted from the source:

I'm seeing a LOT of examples involving variables, in which instead of a colon, there's an equals sign. There must be something to this variables thing. I don't think you can really do much without variables.

That's it for today. Back on vacay.

## Monday, July 29, 2019

### Learning CL: Day 4

After a brief time away, today I resume my CL journey.

I started out by re-reading my own posts, and suddenly had the urge to start trying things out myself, starting with recreating the "guess the slope of the dashed line" activity. Made me see a few things:
1. Why there has to be a y = ax on the graph screen, so that the slope (a) that the student inputs gets sent to that value in the graph.
2. I allowed the slider to be created, and it didn't seem to make any difference. The y = 0.5x graph shows up no matter what, but the y = ax one only shows up once a value for a has been input.
3. The script gave a warning because I hadn't checked the f(x) math box on the input. Then I was allowed to use the numericValue part. Not checking that makes the input component a text, so the type wouldn't match.
I then did a few more screens with a similar example right away to reinforce all the things:

number("a"): exp2.numericValue  is the script inside in the graph's gearbox. number("a") means that some part of the graph is expecting a number it's calling a, exp2 means it will get that numerical data from a component called exp2, and .numericValue means that the type of data is a number, not text. Worked.

Just not sure why we need to say number at the beginning and then numericValue again at the end. Going back to the CL documentation.  Under "About the CL Language", it says that "every sink expects a specific type, and every source emits a specific type." So in the examples I made with the graphs, "number" is at the beginning to specify that the graph component is a sink that expects a number. Note: Other words you can have at the beginning of a script are string, or boolean. (What about content, isn't that a possibility too? yes - see the table with the heading "Note")

Under "Sources" it says "each component has a different set of sources". So a component can have more than one type of data in it - in the example here two types come from the same component, one being numericValue and another latex.

It seems that the word "number" at the beginning of the script refers to the sink's data type, and the numericValue at the end refers to the source data type.

So what comes after the dot is the type of data we are extracting from a component. There are tables with headings "Sources" listing all the things that could come after the dot, and others with the headings "Sinks" listing all the things that could come before the colon.

I just remembered something Andrew Knauft sent me on twitter:

There's that sink at the beginning before the colon or the equals, and the source at the end after the dot. And the component name in the middle.

Starting (slowly, slowly) to see a structure.

## Sunday, July 21, 2019

### Learning CL: Day 3

Yesterday ended with a whimper. I became thoroughly confused and discouraged. Again. I think I've come to the end of the big picture explanations on the Desmos CL doc. The rest is a huge list of scripts that fascinate and terrify.

To keep track of open questions, I'm going to bold them.

Today I'm going to look at Jocelyn Dagenais's (@jocedage) Intro to CL collection that he very graciously shared with me on the train back from OAME this May.  By the way, OAME (Ontario Association of Math Teachers) puts on one heckuva great conference. Next year it'll be in Oshawa, and the lineup is just stellar.

Example 1:

Shows me one major advantage with CL, over using just the regular activity builder, is that on a single screen, you can have a graph AND an input, and the graph is not static - what the student types in the input immediately shows up on the graph. In the regular activity builder, that could only happen if the graph was the only thing on the screen, and students could get things to appear on the graph as usual with the Desmos graphing calculator. (The problem with that is that sometimes they accidentally got things to disappear too tho!) In activity builder, as soon as you'd add any other component besides the graph to a screen, the graph became static to the students. With CL, they can type their equation in the input box, and see the graph on the same screen, and there's no chance that they can inadvertently delete anything from the graph, which happened a lot.

In screen 1, there is a note (with instructions), an input (with the latex option selected), and a graph. They're all labelled - note1, input1, and graph1. The script is behind the graph:
function("f"):simpleFunction(input1.latex)
I guess that since the script is in the graph's gearbox, that means that whatever source is specified in the script will automatically be linked to this graph? In other words, there's no need to specify that the input is the source? Is there ever?

Anyway, I get that the : indicates that the graph is something that will receive (bc it's a sink) data from somewhere else, and where it will receive data from is indicated by the "input1" part. The dot latex specifies the type of data. For the simpleFunction part, I looked back at the Desmos CL doc and found this under Functions:

#### simpleFunction

Takes a latex string and returns a function which can, for example, be passed into the function sink of a calculator.The first argument is the latex string, and additional arguments are The names of the variables to treat as input variables (defaults to)one-variable function in terms of x if not specified

So that explains why "simpleFunction" is there, it's giving instructions for what to do with the argument. (argument here must means what's in the brackets).  "The first argument" would be "input1" and that's what students are typing into the input box, which is being interpreted as latex bc Jocelyn selected that when he made the screen. This script says to put whatever the student typed in note1 into the graph, and graph it.

Did the graph and the note need to be labelled here? They're not referenced in the script. No they didn't - I just deleted those labels and all still worked.

Example 2:
Also has a graph and a note, but instead of an input, a table, labelled graph1, note1, and table1. The table allows for 3 different functions to be typed in, and so 3 functions to be graphed at the same time. The script is again behind the graph:
function("f"): simpleFunction(table1.cellContent(1,2),"x")
function("g"): simpleFunction(table1.cellContent(2,2),"x")
function("h"): simpleFunction(table1.cellContent(3,2),"x")
The "cellContent(1,2)" must be a data type and also point to that particular cell in table1. It's the source for which the graph is the sink. So I don't need to specify anywhere that this is a source, it's understood by the simpleFunction syntax I guess?

The x would be the "additional arguments" mentioned under "simpleFunction" above. Not sure why it's in quotation marks. This looks different not only because it's a table instead of an input but also because this time the latex wasn't selected by Jocelyn, although it doesn't appear to be an option anyway with tables? So the data type isn't latex. I don't understand why then, when I, as a student, type x^2 into the cell, it displays not as x^2 but in the proper superscript notation? Played around with a sandbox activity - each column of the table has a pull-down menu, where you can toggle between "format as text" and "format as math". The initial default is math.

I also noticed if I click on "edit graph" to see the actual graph (I'm in teacher mode), that the first 3 rows of the expression list have got f(x), g(x), and h(x)  typed in them, but the orange alert triangle is showing. If I remove those 3 rows, the graphs no longer show up when I type in a function as a student. Same is true of example 1, didn't notice that before. So in order to use the graph as a sink I need to label the row(s), kind of like the table cells were labelled.

Example 2.1:

Similar to previous example but allows for implicit equations, like conics, to be entered into the table cells. The script looks very different though:
eq1 = parseEquation(table3.cellContent(1,2))
eq2 = parseEquation(table3.cellContent(2,2))
function("f"): eq1.differenceFunction("x","y")
function("g"): eq2.differenceFunction("x","y")
The first 2 lines define variables eq1 and eq2 and they are whatever is typed into the table cells. Looked up parseEquation:
parseEquationTakes a latex string, e.g. "2x+y=1" - and returns an equation object

While looking through the CL doc for "differenceFunction: I saw this:

#### allowEraser

Sometimes you only want students to be able to clear, not erase. Set this to false if that's the mood you're in.
They crack me up those Desmos folks. Ok so I differenceFunction says

#### differenceFunction

simpleFunction representing for (lhs) - (rhs) of an equation. Useful for setting equal to zero to test or plot
Sooooo hmmmm. This may be where I stop today. This must be what my students feel like when they say - I can follow when you do it Mrs, but I know I couldn't do it on my own. But it definitely helps to have these examples, and the CL doc list. Today was better.

I'm off to Austria for a week or so, and it's highly unlikely that while I'm there I'll be computation layering, especially as I'll be at a GeoGebra conference, and learning all kinds of GeoGebra stuff there.

## Saturday, July 20, 2019

### Learning Computation Layer in Desmos: Day 2

Re-read my own notes from day 1, and I feel pretty ok with it. Still reading the Desmos CL documentation.

Sources:

So there's naming a component, which is different from script. You can name a component and not have any script associated with it, but not the other way.

"We can read things off all of its sources." I don't know what that means. (see day 4 for answer)

On screen 5, in the input, I entered 4^2, and this is what happened:

So 4^2 is being both converted into proper math notation AND evaluated. In GeoGebra, this happens in object boxes. To display 4^2 properly you use latex, and to display the value of 4^2 you type exactly that into an object box. Anyway.

The script was in the gearbox for the note. I just realized that I'm not sure where to put the script. Would it have made sense for the script to go anywhere else than under the note? Anyway this part of it defines the content sink with the : and the quotation marks enclose the string to be displayed. Not sure what the \${} is about. The script looks like:

content: "
You entered: \${l}
which evaluates to: \${v}"

Earlier in the script the variables v and l are defined:
v = exp5.numericValue
l = exp5.latex

and both those variables belong to exp5, which is the name of the input. So does this mean the exp5 is the source here? I typed 4^2 into the input and it got injected into the note AND the input. Soooooo the input is the source and the sink here?

Moving on, but not feeling steady.

Functions:

So the = is used to define a source (or a variable) whereas the : is used to define a sink? This script

latex = exp6.latex

uses exp6 as a source. I don't know why the word latex is at the beginning, but I think the one that's after the dot is there to define the type of data it is. Also, I don't know why we're seeing false and true suddenly.

Am I getting confused because I'm assuming I should already understand this but it will in fact be explained later?

Day 2 not going so well. I think it's time I looked at Jay Chow's site.

## Friday, July 19, 2019

### Learning Computation Layer in Desmos: Day 1

I've decided to document my learning, questions, notes, neuron-firings...and my poor ol' neglected blog seems to be as good a place as any to do that. I'll use italics when I think I've answered my own question. I want to make clear that all this is in no way meant as a critique of the Desmos team's writing or teaching abilities - both are epic. I'm expressing the thoughts/reactions/difficulties I'm having as I work through it all, in case I am not alone, and in case there's someone out there who can untangle this for me.

Day 1:

I've read this before, not sure why I think this time will be different and suddenly all will be clear, but here goes.

First words that I get snagged on "Sinks are the data that you set for a component. The text label on an action button. A variable in a graph. The text a student sees in a note." "set for a component" means inject into a component so that component now contains that value? The example with the slope and the graph confirms that to be the case.

Next snag: "graph and math input" this terminology seems important but it is sort of appearing out of nowhere. I'm inferring from the example that a math input is a number? Ohh input refers to the type of component, nothing to do with CL, it's just one of the options you can put on a screen when you make any Desmos activity? I straight up did not get that any of the other times I read this. Holy crap.

"Next we'll need..........exp1" good, clear, I expected that the source needs to have a sink. But then "To add a CL scriptwhere did "script" come from? (answered later) And "preset options"? I believe preset options are the set of possible data types for a given type of component. Eg in an input component, if the f(x)math option is selected, the data type must be number or latex, and if text is selected, the data type has to be content.

The "Try It" is great, and it also shows the actual activity screens where we can look into the gearbox. I'd like to have Try Its for my kids somehow somewhere about something. Now I see that the input, which is the source, only needed to be given a name, but the graph, which is the sink, needed more - it needed what I'm guessing is the script, or instructions, which look like this: number("m"): exp1.numericValue .   (There's that syntax that confounds me but I know this is just an intro example)

"Data types" "strings" more new vocab. Starting with 3 simple data types number, string, and boolean, and my question about strings is answered.

"General syntax" - deep breaths.

Sinks are always followed by a ":" "For example, the "content" sink of a note lets you define what the note says"  and I am snagged. Don't know what content sink is. But at least I now know that note is the same as the note component in a Desmos activity.

content: "Hello! I'm the computation layer!" so the colon after the word content means that this component is being defined as a sink? Yes! In other words, something whose content is coming from somewhere else? Not really, it's coming from what's between the quotation marks. Also I notice the "overriding whatever's already there" - that's important to note but then why would anyone even type anything in the original note if it's not going to show up because of the CL? Because only the teacher would see what typed in the original note, and that might be a note to self type of thing. Also not sure why this is a sink. I got why the graph in the previous example was a sink, something in it was coming from another component, which was the source. But what other component is the source for this sink? There isn't in this case, because what's being injected into the note is what's between the quotation marks. It's functionally equivalent to just typing "Hello...layer!" into the note And I don't know why the word "content" is even there. Because that's the data type for this sink.

"Some sinks take a single parameter as an argument" new vocab again. I mean I know what argument and parameter mean in math but not here. They mean pretty much the same thing here.

number("m"): 1.5
number("b"): 2

I see the colons which mean that these components are sinks. But suddenly there are brackets and quotation marks, which I'm sure will be explained later, but I'm starting to feel like I'm getting lost again. And there isn't a source component for which this is the sink? The source is just the numbers 1.5 and 2? Yup. In this case, m will always only be 1.5 and b will be 2. Functionally equivalent to typing y = 1.5x + 2 in the graph.

Variables: I do not understand this at all. Oh. In the Try It script I replaced "hello world" with "wut up" and that's what was displayed in the preview! So the script content: greeting means that whatever the content of the variable "greeting" is will be displayed in the note.

"You can reference variables defined....using the script keyword" I did the same experiment, changed hello world to wut up on screen 3 then the preview for this screen, screen 4 showed wut up.
content: note3.script.greeting the : means this component is a sink, script means I guess use the script that accompanies the variable greeting. What is the "note3" for tho? I don't see anything - wait it's on screen 3, that's the name of the note on screen 3. But why is it here in this script and doesn't this make note3 a source? It does. Not sure what my confusion was about here.

Sources: : "Each component has a different set of sources" - has or could have? Does this have anything to do with data types? Yes.
"expression input" new vocab. "We can read things off all its sources" now it sounds like they really meant "has" and not "could have".

Been at this for about 1.5 hours. Back to vacation hours.

### Learning the Desmos Computation Layer

I have tried to get my head around this. It's not that I don't understand the whole source/sink thing, and it's not that I don't get the big idea - that when you add CL to your Desmos activity, what happens during the activity depends on what the student does - I get that. I love that. It gives Desmos that conditional property that I use so much in GeoGebra. I WANT THAT.

I think it's the syntax that escapes me. I wish someone could just make a diagram about that - this goes here, this needs brackets...anyway if I ever figure this out I shall try to make something like that myself so other people in the age range in which I find myself have a chance.

So for now I'm trying again, starting with the Desmos CL documentation. I'll also use Jay Chow's (@mrchowmath) resources, and this treasure trove of a collection that Jocelyn Dagenais (@jocedage) shared with me.

Wish me luck, I'm going in.