/CS50 2016 – Week 10 – JavaScript

CS50 2016 – Week 10 – JavaScript

Video: CS50 2016 – Week 10 – JavaScript


SPEAKER 1: All right, this is CS50, week 10. And you'll recall that last time we introduced one of our additional languages in CS40, that of SQL, Structured Query Language. And this, recall, was a language that we used to query databases, insert data into databases, delete, update, and more, so that we actually have a way of persisting data once we built a web-based application, or really any other application that we want to be able to store data long-term. And we had such statements as create for creating a database or a table, insert, select, update, delete, and a few others as well. And with these relatively few building blocks, we're able to start building a back-end for a web service.

And indeed weeks ago when we first implemented a front-end for Google, simply by implementing that web form, we didn't really have anything to do with the data or anywhere to query for data. But now we actually do via our own database in the form of SQLite and via this new language, SQL itself. But today we introduce really the last of our formal languages in CS50. Recall that we began the semester with Scratch, transitioning quickly thereafter to C where we spent a lot of the semester. We have since pivoted to Python of course, whose syntax is quite different, but whose ideas are really fundamentally the same. Today we transition to JavaScript. And JavaScript you'll find is more syntactically similar probably to C than it is to Python itself.

So you'll see that a few more parentheses are back, perhaps some semi-colons as well. But what's most important today is that really the fundamentals of programming aren't changing. But rather the method via which we actually execute or run this code. In particular, thus far, when we've written C code, when we've written Python code, all of that code has run on the server, so to speak, within CS50 IDE or maybe on your own Mac or your own PC if you have some prior programming experience. But today we introduce a language that is generally, though not always, used within the client, the browser. Which is to say the code that we start writing today– and when you generally use JavaScript in order create front-end user interfaces, you will find that the code you write, like HTML or CSS, is actually sent to the user's browser where it's executed, again client-side, on the Mac on the PC. It is not executed server-side. Now to be fair, JavaScript can be and is increasingly used on the server-side as well via frameworks called Node.js, if not others.

But we'll focus predominantly on client-side usage thereof. And you'll see that you can start to do some pretty powerful things, because not only now do we have the ability to have a dynamic back-end that serves up data and searches things for us, but a front-end that gives us all the better user interface and features still. So I was thinking back yesterday on when I first started using JavaScript. And it was in a very, very small isolated instance. But way back in the day– and this is thanks to the wayback machine, you may recall Frosh IMs was something I did in college. Not so much in sports but more the website. And this was essentially the layout– apologies– of the Frosh IMs website some years ago. Now this actually post-dates me by a few years, since it seems the codebase actually survived me by quite a few years, surprisingly.

But early on, when you would hover over these menu options at top right, those would have what are called event listeners attached to them so that when you hover over some of those menu options, the color would actually change. And I think they shifted positions slightly. So [INAUDIBLE] ultimately took over the site and took it further than that. But this was my first taste of JavaScript. And it was just to give the website a sense of dynamism and to give it a sense of interactivity that wasn't possible, certainly not at the time, with HTML alone. So let's do a quick compare and contrast of JavaScript with things we've seen in the past, just to kind of bring ourselves up to speed on some of the syntax. But you'll find we need to spend relatively little time on the syntax and the language itself, because you'll find syntactically it's so similar. And so instead we'll focus more on ideas and new features of the language itself.

So as in C and in Python, we have the ability to express functions in JavaScript. They look a little bit different, at least at first glance. But fundamentally they're really the same. In JavaScript, if we want to function, we're going to use the keyword function to say, hey browser, here comes a function followed by the function's names, zero or more parameters, and then between the curly braces a bit of code that implements that function. So gone is the ability to just indent your code and have the interpreter know what you mean. Those curly braces are back as are more parentheses for us here in JavaScript. But in terms of loops you should find this fairly familiar. In JavaScript if you want to iterate over something again and again and again, the do while construct is actually back. So we have something very similar here as we do in C.

And what you use that loop for can be any number of things. But we do have that capability again. Similarly, do we have while or while true loop here, which would induce an infinite loop. And again, these are the kinds of things that might trip you up unnecessarily at first, but quite reasonably. Like if you start capitalizing true again, it's not going to work in JavaScript. So again, reasonable people will disagree when it comes to designing these languages. And so the authors of JavaScript decided to lower case true and false, where again in Python we've been capitalizing recently, true and false. Meanwhile, if you want to declare a loop using a for loop, that is back. But you'll notice perhaps implicit in this example is the fact that JavaScript is, like Python, not strongly typed. It does have the notion of data types. And you can access or look at those data types.

But you don't have to specify them as the programmer when you're declaring variables. Rather, in the case like this, when you're declaring a counter like I, which should be an integer from 0 up to 50, you literally say, var, for variable, than the name you want to declare and then just the rest of the syntax is as we've seen before. Meanwhile, there's another handy feature– and you'll see this in use in various examples perhaps online– is the very easy ability, like in Python, to iterate over the keys in an object. So recall that an object, at least in Python, is really just a collection of key value pairs. But it's an object can also have methods inside of it. But if we focus entirely on data, keys, and values, this syntax here would allow you to iterate over all of the keys and some value coming back.

So maybe if you have a stock object, you could iterate over its name and its price and its symbol, simply by using syntax like this, and an index into the object to get at that object's value. Meanwhile, variables are fairly straightforward. To declare a variable like I, we would say var I equals 0, and a semi-colon. Boolean expressions, meanwhile, are with us still. And these are no different. I is less than 50 might be expressed with this. X is less than y might be expressed with this. So nothing new there. Meanwhile with conditions, we have syntax identical to C. So again, the curly braces are necessary, at least if you have multiple lines that you intend to be associated with the if or the else if or the else. Again we're back to, else space if, instead of L if in Python. But again, there's nothing really new here in terms of content, really just syntax. So after practice and after some trial and error, you'll generally find that it becomes second nature.

Meanwhile, we have arrays in JavaScript. So for instance, if we want to declare an array called numbers, again we don't specify the type of this array or the members therein. We simply say var, to give us a variable, number shall be the name of that variable. And then a list here of arbitrary numbers themselves nested in between square brackets. So in JavaScript, as we've seen in Python, we have the ability to express lists or arrays specifically in JavaScript that simply use square bracket notation to define them in a context like this. Meanwhile, speaking of objects a moment ago, we have that same ability in JavaScript to declare them. So for instance, if we wanted to declare an object, and we'll call it quote, we use, as in Python, curly braces. And I say as in Python because in Python really when I say object, focusing entirely on data, I really mean a Python dictionary or dict object, which again is this collection of key value pairs. We don't necessarily do things quite the same way.

But in this case here, var quote is a way of porting, say, from a CS50 finance example, a company's name and its price and its symbol. And worth noting here, that as in Python, you actually have choice over the quotes that you use, at least in this context. Single quotes are fine. Double quotes are fine. So long as you are stylistically consistent, it's probably fair to say that many people in the JavaScript community tend to use single quotes here. There's no functional difference as there is in C. However, they do matter, as you'll perhaps eventually see, when you're using not JavaScript per se, but JSON notation. JavaScript Object Notation, which is a simple data format not unlike CSV, but that allows you to store a hierarchical data inside of an object. And the subtlety there is that when you want to store data in this JSON format, you have to quote literally everything with specifically double quotes on the left and on the right. So it's an annoying distinction. And don't fret too much about it now.

But just realize any time we're talking about JSON and a technology called AJAX– more on that soon– it's got to look like this with the double quotes on both sides of the colon for those key value pairs. Now with that said, let's start to give ourselves some context. Let me introduce a few features that we've kind of sort of seen in Python– didn't necessarily leverage, but are going to be really integral to the way in which many people use JavaScript within browsers. So here, for instance, is that old simple example of HTML, perhaps the simplest web page that we can write, that quite simply says in its title and its body, hello world. And recall that the indentation here is functionally meaningless. The browser doesn't really care how pretty your HTML looks, just nicer for us humans to see everything nested and nicely indented, because it's just a lot easier to read.

And it's also a lot easier to detect if you type something wrong, if something doesn't really line up as you expect. But another way, recall, of viewing this same piece of HTML is in the form of a data structure like a tree, which we discussed way back when in the context of C. And we might draw this same example of HTML with a Dom, document object model, which is a fancy way of saying tree. And that tree might look like this. It's got some special root node that we'll just generically call document, because there might actually be some other stuff like comments or whatever up there. But the root element of a web page, recall, is HTML. The second thing you type is open bracket HTML. The first thing you should type with HTML5 is open bracket doc type HTML. So you can think of the doc type as meaning this node essentially, and the open bracket HTML close bracket meaning this root element. Of course this page here has both a head and a body.

That head a title, and that title has a text value inside of it, or a text node so to speak as does the body that happens to be identical. So what's nice about this mental model is that if we tie everything together from weeks past, sort of the markup language of HTML and the data structure of trees and specifically this Dom here, it turns out that you have the ability with JavaScript– something we didn't have in C really and didn't really have with Python– but the ability to change this tree in real time. After a browser has downloaded some HTML from a server, typically that content has been static. You can open up Chrome's console in the elements tab and futz with it manually, but those changes aren't persistent, even though you see them.

And certainly no user, or no typical user is going to do or know to do that. But you the programmer, if you want a user to be able to download some web page, but then interact with it and have that content change– very similar in spirit to something like Gmail, whereby every time you get an email, a new row in your inbox appears without the whole page having to reload and certainly without you having to click Reload. Or something like Facebook Messenger, where no matter the time of day if you have Facebook open in a tab, it's just going to pop up a message and keep adding to that little window– another line, another line, another line of text. So there's this dynamism you get that you can't get from HTML and CSS alone, but you can with JavaScript. If you think of it just intuitively, if you have the ability to run code inside of a user's browser, you could have essentially kind of a while loop that's just constantly waiting. Did the server send me more data? Did the server send me more data? And if so, go ahead with an if condition and write more text to the web page.

Write another message in the little Facebook chat message. Write another row to the Gmail inbox. And that's what we're going to get and more with JavaScript. And it turns out, with JavaScript, can we listen for a whole bunch of events so to speak. I eluded to an event, a listener being attached earlier. And this is just a small sample of the events that can be triggered within the confines of a web page. So unlike our Python programming thus far, and unlike our C programming, we have in JavaScript this asynchronicity. Multiple things can kind of sort of happen at the same time or really at unpredictable times because users, of course, are interacting now with our web pages. And who knows when or where a user is going to click. Who knows when he or she is going to click and drag something across the screen or select some menu option or click check some checkbox.

So we can't really just write a program top to bottom in JavaScript as we've done in the past per se. Rather, we have to start writing code that says, if I hear a mouse click, or if the user drags their mouse, or if the user checks a checkbox, do something. So kind of like if this then that, if this then that. So a lot of conditions. But it turns out that it's relatively simple to register functions– that is, associate functions with these various events. And so for instance, when you check a box in Gmail and all of a sudden the row becomes a different color or whatnot, that's because there's an event listener for the click event that Gmail is saying, as soon as the user clicks this event go ahead and change the color or change the interface in some way. Or if you click the little X in the top right-hand corner of a Facebook chat window, the reason it goes away is because there's a click event happening. And Facebook has written code that listens for that click event.

And as soon as they hear that event, they close the window and remove it from the web page altogether. So Google Maps, for instance– drag is an event. So if you've ever kind of wondered, well, how do I click and drag in Google Maps and they just know to show me more of the map, whatever direction I'm clicking in, they're listening for the drag event. And so this is where things get really interesting with GUI side programming– graphical user interface programming. There's this whole event model, where a bunch of events, a bunch of things can happen at any number of times. Or at any point in time. So let's offer a few general definitions of terms and features of JavaScript. But let's actually discuss them in the context of examples. So JavaScript supports and really, really leverages, typically things called anonymous functions, otherwise known as lambda functions. And these quite simply are functions that have no name.

And that seems a little strange. But we will see contexts in which functions don't need names if you're only going to call them once, or if you only need to refer to them really once. So we'll see how to declare and define a function that doesn't actually have a name like foo or bar or whatever. Meanwhile, we're going to see a methodology involving callbacks, which is very similar in spirit to the events I rattled off a moment ago. Whereby a call back is just a function that's supposed to get called when something happens. So in other words, Google and Facebook with those user interfaces, they are registering functions. Really, they're registering callbacks, so that when the user clicks on an X or when the user clicks on a checkbox, or when the user clicks and drags on a map, they have in advanced register a function that gets called back. It's like leaving a message for someone on voicemail. They call you back in response to that voicemail. They call you back in response to the beep that their phone makes when they've received that.

So it triggers some kind of functionality, these callbacks. Callbacks are just functions that have been configured to be called at a certain point in time when something happens. Now meanwhile, and lastly, we'll talk about AJAX, which isn't a technology unto itself but a use of various existing features within browsers that allow you to query from a browser, a server to get more data even after the original page has been loaded. Let me go ahead here and create a file called, say, Dom 0 dot HTML. Document object 0 dot HTML just to line up with some of the examples that we'll place online for everyone to play with. I'm going to go ahead and start my page as I usually do. And I'm going to go ahead and say HTML. And then in here I'm going to have a head tag and in here I'm going to have a title tag.

And I'm just going to call this Dom 0 for simplicity. Down here I'm going to a body tag. And in here I'm going to have a form. I'm going to give this form, similar in spirit as we did in our discussions of CSS, a unique ID, simply so that I can refer to it as a demo, a demonstration. But let's come back to what more I want to associate with that. First let me go ahead and give it an input, an ID of names so that I can refer specifically to this input field. Let me give it a placeholder of name. And let me say that the type of this field is a text field to close that tag. And then input type equals submit. So a very, very simple web page that looks like this. Now what could go wrong if I present a user with a web page like this? Well, he or she might not give me their name. They might just click submit and this form is going to get submitted to some server.

Well that doesn't seem all that great, because I don't have a chance to check, did they actually type in a name? I don't have a chance to do something with it on the client. And indeed that's now the new feature we get with JavaScript. Notice what I can actually do. Let me go into the head of this web page, where thus far we've pretty much only put the title tag. We've put the link tag for CSS. And you may have seen with CS50 Finance that we also had a script tag that referenced a library called Bootstrap, and another one called Jquery. More on those in a bit. But indeed, inside of the head of a web page can go with script tag. And you know what, inside of a script tag can go code, specifically JavaScript. And in here I can define a function, literally. I'm going to call it, greet, just to kind of say what it does. And inside of this function I'm going to do the following– alert, quote unquote, hello, comma, world, semi-colon.

So this is how in this example I've defined a function called greet. I've put it inside script tags, open and closed inside of the head of this web page. Now, nothing's going to happen with that unless I tell the browser to do it on an event. So I'm going to go into my form tag here and say on Submit, go ahead and execute the following code. Go ahead and call the greet method and greet function, and just for good measure return false. But more on that in a moment. So again, my function's defined up top. But nothing happens. Again, when you define a function, nothing automatically happens until you call it. So when am I going to call it? On the form tag here, I have an on submit attribute, which is new today, that says, call the greet function and then return false. But again, more on that in just a moment. So what actually happens here? Let me go into another window, open up DOM 0. And you'll see, if I now zoom in on this form, will see that it's a very simple HTML form with just a name field and a submit box.

And if I go ahead now and type in my name, David and click Submit, hello world. So it's not actually saying hello, David, it's just saying hello world. But notice what happened. This is a very bad user interface just using this built-in prompt. But it demonstrates the built into JavaScript are a bunch of functions, one of which is alert. And that function is designed to do exactly this. The window will look a little different if you're using Chrome or Edge or Firefox or Safari or whatever other browser, but you'll see that it simply says, hello world. And it's going to say whatever the URL on your page happens to be. In my case it's just this local IP address for lecture's sake. But this isn't all that interesting to just hard code, hello world, especially when I have the opportunity to take in a user's name. So if I instead go back into my code here, and don't just print out, hello world, but perhaps concatenate with JavaScript's plus operator, the result of this method call, document dot get element by ID, quote unquote name, then dot value. So that's a mouthful.

Let's see what this does before we explain what it does. Let me go ahead and reload the page. And now we see the same form again. But this time I'm going to type in David and click Submit. And now it says, hello, David. So how does this work? Somehow or other, I wrote code that not only alerts the user with this window, but it somehow grabs data that he or she has typed in and embeds it in this message. Well here is where we can leverage the DOM, the Document Object Model, and a bunch of functions that come with JavaScript that allow you to programmatically get elements and get data ultimately from a web page. Specifically notice we're doing this. We're calling alert, and then open paren close paren because it's a function call. Quote unquote hello comma, with a space. And again, single quotes, double quotes, doesn't matter so long as I'm consistent here. Plus, which is concatenation, document doc get element by ID, quote unquote name, dot value. So it's kind of a mouthful and it's definitely verbose. And we'll see before long slightly more succinct ways of expressing this. But you can think of document as being this special global variable that's just accessible to JavaScript code that you write.

And that really is that uppermost node in our tree, that top-most node in our DOM. And associated with that node, which is just an object, are a bunch of methods or functions, that just come with JavaScript, and that your browser just supports for you. One of those is called get elements by ID. And recall, we've used this jargon before. An element in a web page is the combination of an open tag and a closed tag and everything in between it. So get element by ID quote unquote name means, hey browser, go get me this entire element from start to finish. And this is an empty element because we've closed it within the it's own tag. So that just means, go get me. Kind of a pointer to that node in the tree. There's no pointers in JavaScript. So we should really call this like a reference to this node. But it really just means that. Go get me somehow this node in the tree. And what do I care about once I have that node? I care about its value. So dot value, you can think of like syntax like a struct.

That means, if you have this node now, via get element by ID, go inside of it and look for the field with a property called value. And that's going to line up, it turns out, with exactly what the user types. So I can do this again to be clear. Let me go up here and for instance type in Andy and click Submit. And voila, now it says hello, Andy. But now the browser– and this is perhaps a curse from 10 and 20 years ago when people started to abuse JavaScript and give you hundreds of popovers so to speak, hundreds of prompts if you visit a website that's trying to mess with you. Chrome and other browsers will let you check a box like this, prevent this page from creating additional dialogs, just because it thinks that maybe the page is buggy, maybe it's malicious, and it's really just pestering you as these things are annoying. But at least during CS50 development for P-sets projects, don't check this because it'll only confuse if the page no longer does as you tell it to do.

Fortunately that doesn't come up too often on actual websites. All right. So we seem then to have the ability to not only get data from a web page programmatically and display it dynamically. But can we design this code a little better? Well it turns out that we technically don't need to co-mingle our code and our HTML. And notice too there's one other line of code here that's a little sloppy. I mean literally between these double quotes do I have two statements– greet, which is a function call, and then return false. The reason I had return false is that if I didn't, after clicking Submit and submitting this form, the only thing stopping this form from just being submitted to the server is return false. This says, hey browser, even when the user tries to submit this form, don't. Return false. The default is true. Otherwise, if I didn't have return false and I click Submit, I would see that alert as expected, but the moment I dismiss it, I'm going to be led to some other web page, presumably wherever the form is going to be submitted, which coincidentally happens to be the same page.

But now that we're developing client-side applications, client-side web apps, we don't necessarily want forms to be submitted to the server. We want to use them, for now, only within the confines of a browser. Indeed there is no back-end, there is no action attribute for this particular example. But this feels messy. Any time in CS50 when we've introduced some new language like CSS in the context of HTML, or our HTML in the context of Python via our Jinja templates, did we try to factor out one language from another, so as not to blur these worlds and make the code very messy, very unmaintainable. So how can we begin to remove, from these quoted values, code, but still have this feature of listening for a form submission? Well let me go ahead and propose another variant of this program, that I'll go ahead and call DOM 1 dot HTML. I'm going to start with the code from before, but I'm going to make a few changes. Instead of putting it in the head of my web page, for now, I'm actually going to put it down here in the body.

READ  Storing Images or Binary Data - Developing Android Apps

More on that soon. But instead of even declaring this as a function, I'm going to instead simply do this. I'm going to get rid of this event handler. So now all that remains up here, to be clear, is just pure HTML. I still have those ID attributes so that I can uniquely identify those forms and that form and those inputs if I want, or that input if I want. But notice what I can do now. Document dot get element by ID quote unquote demo, because that's the name of my form, dot on submit, gets function open paren close paren. And then just for stylistic purposes, let me go ahead and do this, which is what most JavaScript programmers would do. So what am I doing now? Now I have pure HTML appear. But to be fair, I now have a script tag inside of which is code. But at least I've removed the code from like an attribute, which just looked or felt a little sloppy. And look at the code now, document dot get element by ID demo. So this gives me essentially a reference to the entire form, not just that name field.

And it turns out that provided that node in the tree is a form, and indeed it is, that has associated with it a property by the definition of HTML5 called on submit. This is a property, that if you assign it the value of a function, that function will get called when the form is submitted. And yet what function do I want to Call Well, function open paren close paren seems to omit a key detail that we've seen in Python and C, which is the name of the function. But here's an example where I don't care what the name of this function is. I don't need to know the name of this function. Because all I need is a function, a chunk of code that will ultimately get executed when this form is submitted. And that line of code is identical to what it was before. So just to be clear, this anonymous function, so to speak that I'm using, is not strictly necessary. If I really wanted to, I could do something like this. I could declare a function called greet, just as before. And I'll format it exactly as I did before. And I could declare this right up here.

And then down here I could say, greet. In other words, the on submit handler just wants to know what function to call. So fine. If I find a function call greet, I can tell on submit to call greet. Notice, no parentheses here. I don't want to call the greet function when that line of code is executed. Rather, I want to assign that function, which you can think of as a variable unto itself to this on submit handler. But why? This hasn't really gained me anything. Yes, it's nice that it's called greet. But I'm defining a function called greet only to configure my browser to call that function one line later. The nice thing about anonymous functions is that you can just kind of tighten things up. Why clutter your namespace so to speak? Why fill up your brain with names of functions that you're never again going to need? And so more common and cleaner, better design arguably, would be something like this.

All right. And actually just for good measure because this is all part of a statement, in this example let me put that semi-colon there. So the example is going to work exactly the same. Indeed if I go back to my browser and go into DOM 1 dot HTML and type in something like summer and click Submit. Hello, summer. And so it behaves exactly as before. And for good measure, let me go ahead and change the title here to match the name of the file. But now let me go ahead and open up an example I wrote in advance, like many of these, called DOM 2 dot HTML, the code for which admittedly is much more cryptic at first glance. And indeed the syntax will take some getting used to. And you don't strictly need to do things this way. But a super popular library in the world of JavaScript today to this day is something called jQuery. And indeed the bootstrap library with which you're now acquainted by CS50 Finance actually uses, for some of its features, the jQuery library.

So let's introduce the syntax so that you've seen it, so that you can use it. But realize, this is not giving us any new functionality. It's just giving us a different syntax. And over time, you'll see that jQuery, like certain other libraries, it tends to make it more pleasurable, more efficient to write JavaScript, because you can do things a little more succinctly. The price you pay is a little bit of complexity. So let's take a look syntactically at this library called jQuery. Notice, in DOM 2 dot HTML, I have this URL up here. There's any number of places to get the jQuery library and libraries more generally. But this one happens to be hosted, for instance, at this URL. And it's the latest version thereof. And this attribute source simply says, hey browser, go get the JavaScript code that I want to have access to from this URL, and assume that it's equivalent to my having written in this web page itself, like our other script tags thus far.

Meanwhile, after that, an order is generally important when including things like this. Let me go ahead and do the following. Up here notice that I have this line of code, which generally is a good thing to have because it says the following to the browser. Hey, browser, when the document is ready– that is, when the whole web page has been loaded, when all the bytes have come back from the server, please go ahead and execute the following code. And we'll see that this allows us to ensure that things don't happen sooner than we actually expect. Specifically, let's do the following. When the document is ready I want the browser to execute the following lines of code that I've highlighted here– dollar sign, quote unquote, hash demo. It's kind of a mouthful. But this is simply reminiscent perhaps of the CSS syntax that you might be familiar, that simply says, hey browser, go get me the element from the DOM, from the tree representing this page, that has a unique ID of demo.

So hashtag demo is just a more succinct way of saying, document dot get element by ID. You can do this all in just a few characters. And the dollar sign here is a feature of jQuery. It's actually just a synonym for jQuery. Dollar signs can actually be variable names. So dollar sign quote unquote hash demo means, hey, browser, execute the equivalent of document dot get element by ID, quote unquote demo. Just more succinct, even though it's a little bit cryptic at first glance. Meanwhile, submit, not to be confused with on submit submit– submit is a function that per jQuery's documentation says, hey, browser, register the following event handler for the submit event. The way you do this is you provide the library with an anonymous function, which in this case I've just said function. It takes one argument. And I would only know this from having read the documentation. Function takes an argument that we'll call event. But we can call it call it anything we want. And then inside of this code, what do I want to do when the demo form is submitted? Well, I want to use alert.

But I want to paste in this value. So again, just new syntax here. And it's fine if you prefer the other syntax for now. Dollar sign quote unquote hash name, means go get the element from the DOM that has a unique ID of name, and go get its value using this method call. So jQuery essentially does this. jQuery wraps existing elements in a DOM. It goes ahead and adds like another bigger rectangle around those smaller rectangles that give you additional features, among which is the ability to use these CSS-style selectors, among whose features is to call like dot val and get the value without having to do dot value, which isn't all that compelling in this case. And then we're appending, in this case, an exclamation point for good measure, just so to show that we can to continue to concatenate beyond one string. And then lastly, is this, which granted, more verbose– event dot prevent default just means, hey, browser, whatever your default behavior is for handling forms, don't do it.

Prevent it, because I want to handle this form submission. So this is a really long way of saying, this is another way to implement exactly the same program that we did earlier, albeit with an added exclamation point, which has nothing to do here with jQuery. So why is this a good thing overall? Well one, your code will actually get shorter over time. But it's fine if you'd rather not use this. But this first line was actually rather important. If I instead were to implement this code like this, there's actually a problem. And actually there's a problem even if I were to do it this way. If I were to go back to DOM 1, and I were to do something like this in this example, and not use jQuery at all, but just, in my head tag, have a script tag that has this code here, there's a problem of the order of operations. On this first line, when I say document dot get element by ID quote unquote demo dot on submit, assign that listener this function, it's too soon.

Because the browser at this point in the story literally is reading the file top to bottom, left to right. And the browser has not got to the line of code, where in this form, and its demo ID is actually defined. So this would actually be broken, in so far as the browser's reading it top to bottom, left to right. But it sees this code and it says, hey, browser, go get the element by ID demo. There is no element with that ID at this moment, because it doesn't come until later. So a way of solving this using just JavaScript, is you could do something like the following. Window dot on load get function, and then you could do something like this, albeit fairly verbosely. So that would work. Hey, browser, when the whole window is loaded, then please call this anonymous function.

Or we can use jQuery which frankly tends to be more common, at least when using other libraries as well, which says that exact same thing. And in fact, a little bit more than that via this line of code here. So just another way of doing something, another form of syntax. But we won't necessarily assume that or complicate things by using that library syntax along the way. All right. So now that we have the ability to access data inside of my web page, specifically in forms. And I have the ability to alert the user, it would seem we can actually create useful features, not silly little programs that just say hello, world, or hello, David. What if I now started updating past examples to do client-side form validation? In the past, a couple of weeks back, when we did like the Frosh IMs website, or really any website that submits data– maybe CS50 Finance, if the user doesn't cooperate and doesn't give me a valid symbol or doesn't type his or her name or password or the passwords don't match in the case of registration, the data gets submitted to the server nonetheless and then your Python code thus far has been using an if condition or l if or whatever to check if the user provided the data that you expect.

And if not, you apologize to them in some way by just printing out some message to the screen. That's a lot of work. If you can anticipate that something is wrong, why bother sending all of that data or lack thereof to the server, letting the Python code figure out what's wrong and then wait for this response to get back, even though frankly, it happens pretty fast on today's internet, certainly on campus. That's a lot of unnecessary work if you have a programming language like JavaScript that allows you to run code in the browser. Let's open up an example that we did in the past wherein we just have a form that asks for a user's name, their password, their password again, and then has a checkbox by which they can agree to some terms and then a Submit button. And you'll recall that in the past we might have used something like this to have them register.

And then we said, no, not really, because we didn't actually have a back-end at that point. But a lot of things can go wrong when we present the user with this many things to do. Now we know from Python, we can catch these things, and we can apologize and display an error message on the screen. So we have all of that program added capability. But what if we could create a better UX, user experience. A lot of websites do fancy things these days like, they don't actually submit the form and then show a big erroneous message with a cat. Instead, they just show the text box into which you were supposed to type a value into in red, or green if you got it right. Or a little alert message saying, you need to give us a longer password, or your name, or your email, or your passwords don't match. But you can do all this instantly on the client side, if we somehow can hook into this HTML. So all of these inputs can be uniquely identified, especially if we go at our own IDs. So let's see if we can't take things up a notch and actually write some code that validates a form like this. I'm going to go ahead and do the following.

Inform 1 dot HTML, our next version of this program. We'll start with where I began, with just a simple form. But below this form, just for now so we can get things started, I'm going to go ahead and have a script tag. I'm going to declare a variable called form and call document dot get element by ID quote unquote registration. Why? Well, I'm going to go ahead up here and add an ID that equals registration. And again, here I'm using double quotes in HTML, even though both single quotes or double quotes are allowed. Down here I'm using single quotes, mostly just to be conformant with convention. But you can certainly stylistically do whatever you want with both of these. Now I'm going to do form, which is just an HTML form, and say on submit, get function.

So in other words, hey, browser, when this form is submitted, call this anonymous function. But again, the fact that the function is anonymous really is not an interesting detail. It just means it has no name. This is the chunk of code that will be called when this form is submitted. All right. What do I want to do? How about this. If form, its e-mail field has a value that equals equals quote unquote, that's a problem. Let me go ahead and just alert the user, missing email. And because we don't indeed want the form to be submitted, let me go ahead and return false. Else if, form dot password equals equals nothing– the so-called empty string– then let me go ahead and alert the user that we're missing their password. And then let we return false so that the form does not go through because it's not ready to go through. How about else if form dot password dot value. Oops, and up here I need value as well. Otherwise you get the element from the DOM, you don't get the value inside of that rectangle.

Else if form dot password dot value does not equal form dot confirmation dot value. And why confirmation? Well, if I look back at my HTML, the first field was called e-mail. The second field was called password. The third was called confirmation, even though it's also a password field, because that's where I want the user's password again. But if those passwords don't match, let me tell the user, passwords don't match semi-colon return false. Now wait a minute, my color– my syntax highlighting is all messed up. Why? So this is a common gotcha. If I just want to use English grammar in this case, don't is the right spelling there. But because I have quotes just like in C or in Python when you've used double quotes inside of double quotes, you're going to confuse the program in this case. And so I need to escape this. But as in other languages, escaping a back quote here is as simple as this. Or if you don't really like that because it just looks a little ridiculous and a little harder to read, we could switch to double quotes here.

But again, just because I'm using single quotes everywhere else, I'm going to stick with single quotes and escape it. But again, you could make an argument either way. Ouch. There's still that checkbox. And that checkbox, let's see, was called agreement. So it turns out in JavaScript you can express that as follows. Else if it is not the case that the form's agreement checkbox is checked. So it turns out, associated with checkboxes in JavaScript is a property called checked that's going to be true or false. So if that's not checked, I'm just going to tell the user as much. Checkbox unchecked, and then return false. Otherwise, if none of these checks fail, and I get all the way through all of these if's and else if's and nothing seems to be wrong, you know what, the form is ready for submission, return true. And so now it actually makes a little more sense perhaps, to return false or return true, because in all of these erroneous cases you want to return false. But if everything's OK, by default, we're just going to return true.

And the browser's default behavior in that case is going to be to go ahead and submit the form to the server. So let's try that. Let's go into form 1 dot HTML. Notice that if I zoom up here, we have more fields than before. E-mail, password, password, again I agree in register. So let's try this. Let me go ahead and say, no, I'm not going to give you any of this information. So let me click Register. Missing email. All right, fine. I'll cooperate and give you at least my e-mail, mail in at Harvard dot edu. Let me click register now– missing password. Now there's the additional checkbox there because now Chrome, or your browser more generally thinks that, maybe this website's buggy or it's being malicious or annoying at best. Let me not check that box, otherwise none of the rest of the demo will work.

All right. I'll give you a password. Register. Passwords don't match, that's because I didn't type it again. So let me type the same password again over here. Nice. Ah, checkbox unchecked. All right. Agree, register. Ah, and it even wants to save my password, but not really. So where did this actually go? Well just to show you what's going on behind the scenes, notice that the action attribute of the past couple of forms have been slash register. Well it turns out with today's examples, I'm actually currently running Flask. And inside of there I have a couple of routes. We're going to use one of those in just a bit. For now I'm just using this one here. I have a route for slash register, that calls a function register that simply renders a template called register dot HTML.

So where did that text come from? Again, this is just stuff from a couple of weeks back. If I go into registered dot HTML in my template's directory, it's just that. You are registered. Well not really. So we're not focusing on the back-end. We're not focusing on Python. We're not focusing on Flask. But I do have it running right now, so that we can see what does happen if the form is submitted. But that could be any server in the world. It could even be Google if we're building that search engine again. I just need something running there. Let me go ahead and show you just an alternative take on this form, version two, that does things using jQuery. Again we won't dwell as much on this. But do get familiar with the syntax, because you'll see it everywhere online. This says, hey, browser, when the document is ready, go ahead and associate this anonymous function with the submit handler of the form with this unique ID. And then here a slightly different syntax by which you can select fields on the web page.

Let me wave my hands at that for now. Because again, you can go with the DOM-specific functions we've been using thus far. Or when the time comes, just read a little more closely some of this code here. But this is the equivalent code in jQuery, which is just a library that just gives you different ways of expressing things in JavaScript. But this form is pretty ugly, right? Like, this is really not something to write home about. This also does not suggest the best error handling if every time I do something wrong I just get this ugly looking alert. Can I make something prettier? Well we certainly could with JavaScript alone. And I could certainly write some HTML, some CSS, and a whole bunch of JavaScript myself and get a much better UX, user experience. I could get a much better aesthetic to the site, so that maybe we print some red text or green text, depending on whether the user is cooperating. But that's a whole lot of work.

And honestly, there are millions of websites out there these days. Surely someone else has had to validate a form before, and he or she has done it with JavaScript, and he or she has been nice enough to make their code freely available as open source online so that the rest of us making the other millions of websites can stand on their shoulders and not reinvent that wheel. And indeed, just like in Python, there's lots and lots of libraries, and lots and lots of frameworks, so in JavaScript it's there the same. So it turns out, if I go into form 3 dot HTML, I have a slightly prettier version that is using the bootstrap library. There's no banner or menu or anything like. I kept it pretty simple here. But just by adding a little bit of more HTML markup, and a little more CSS, can I stylize my form to be much prettier. Indeed in CS50 Finance we had much nicer forms than the previous few examples because we used Bootstrap, though you could use most any other library that's out there as well just to make the forms a little prettier.

But I'm adding one additional library. This one that supports Bootstrap, so that if the user doesn't cooperate with this version three, notice they can't even click Register without the following happening. Red email, please fill out this field. Red password, please fill out this field. And by the way, not long enough, because it's not even any characters. Password again, please fill out this field. Checkbox unchecked. So you can immediately give much prettier output to the user without using that sort of a lame prompt that's just going to pester the user again and again. And even though there's still an opportunity, I think, to improve the aesthetics, this is much more akin to web 2.

0. So modern websites that are using these and other libraries to just create better user experiences. So let's cooperate now. M-A-L-A-N. And notice, whoops. That's not even my email address. The error message now goes away entirely because the field is not blank. All right password, 1, 2, 3, 4, 5. OK. It's now no longer telling me to please fill it out, but it's still not long enough. All right. 1, 2, 3, 4, 5, 6, 7, 8. Eight characters seems to be enough. All right. Let me go ahead and type in foo bar baz. Passwords don't match. OK. 1, 2, 3, 4, 5, 6, 7, 8. That one now matches. And finally, I agree. So we get so much functionality for free. We could implement all of that ourselves using just the primitives we've looked at thus far, just our understanding of where JavaScript has to go in the web page, just our understanding of how to write functions and if conditions and for loops and while loops or whatever. But it's not interesting work. If I'm trying to build a finance website or a final project more generally, I don't really want to focus on form validation.

I want to focus on my own intellectual property, my own ideas, my own project itself. And so in form 3 dot HTML is a few additional things. Not only have I included the Bootstrap library at the top, as you might have noticed in CS50 Finance, as well as the latest version of jQuery, and Bootstrap's own JavaScript, I've also included– and I found this just by Googling around. A very nice person made his or her code available at this URL. And there's documentation online. And he or she based it on Bootstrap so that if you want to use Bootstrap and have pretty error messages, that you don't want to think about creating yourself. You can use their library. And indeed, notice how I changed my HTML. It's a little more verbose to be fair, but you'll remember some of this from maybe your log-in form or registration form from CS50 Finance. Most of this just comes from Bootstrap and you're using the classes that they tell you to. But there's a few fields here that control how this new library is working for form validation.

Notice, on my input, not only do I have a Bootstrap class, which I just read from the documentation and in the unique ID, I've got a required attribute. And by saying required, that's a clue, not only to the browser, but also to this library specifically that I should not be allowed to submit this form until this field is filled out. Now notice down here, input class equals form control, which is just a Bootstrap thing. Data dash min length equals 8. This is how that library knows that I, the programmer of this page, wanted the user to type in a password that's at least eight characters long. It turns out, in HTML5, you can prefix, or rather you can invent your own attributes. Any attribute that starts with data dash, and then some other sequence of characters can be your own custom attribute that does not come with HTML itself. So a lot of libraries, this one among them, use those data attributes in order to configure themselves. In this case, it's configuring itself to use a minimum length of eight.

That's also required. Down here it's a little more advanced. But I just figured this out by reading the documentation. Down here, notice, I've got that confirmation text box that's also an input with a Bootstrap class data dash match equals hashtag password. So this is– and you'd only know this from the documentation of the library– this is how the author decided to let us configure this text field in such a way that it must match this password field. And you know what, data match error– I would only know this too from its documentation. But the way the author designed his or her library is if there is an error and the passwords don't match, this is the read text that I want the library to display on the screen. And though it's cut off, this field too is required. And meanwhile the checkbox, if we scroll to the last feature here, that too has been prescribed as required. And notice, I've also added some divs here and there, help block with errors.

READ  Mirror Link na Columbusie

This is not some fundamental HTML thing. This is, again, just the author of the library who's decided that wherever you, the programmer, put a div with these classes, the library will plop those read error messages. So they don't have to be right there. You could centralize them at the top of the screen. You could put them in a banner at the bottom or wherever you want. You have some programmatic control. And so this library is implemented in JavaScript, though we haven't written any additional JavaScript code because this author has been pretty clever and is using special HTML attributes to configure his or her library. And it suffices, at the top of the page, simply to include that library. And it has been written, probably with a line of code like document on ready. Like when the document is ready, search the HTML for those special tags and make sure that this form shall be validated accordingly. So this is what's really exciting about JavaScript and Python as well, and any of these higher level languages is just how many features you get access to for free, without having to implement them yourselves.

How you use them is going to totally differ. And indeed, part of the process of making a final project or a web application or a mobile application in general, is using a fundamental understanding of programming and loops and conditions and functions and so forth, but then googling around and looking up documentation that empowers you to do other things with that understanding, using other people's code. So again, the goal is not to absorb all of this en masse, but rather to realize the fundamentals, the ingredients by which we can configure and do things ourselves. Let me go ahead and propose now this example. So back in my day, when I first learned HTML, for better or for worse, mostly for worse, there was a blink tag. So someone back in the '90s thought this was a good idea. Let's empower people to have blinking text on their screen for everyone to see. There was even worse, perhaps, or as bad, like a marquee, where you could scroll text across the screen from left to right or right to left– I forget which direction– and that too felt like a good idea at the time that has since been removed as well.

But it invites an opportunity, I dare say, to reimplement this feature, even though browsers do not support the blink tag now. But I can figure out how to do this. Right. What's going on? There's some big text on the screen, that's roughly centered. So I can probably use some CSS for that to make it big and bold and centered. It's blinking on and off. Well what does it mean to blink on and off? Again, reduce this to first principles. What capabilities does a browser have? Clearly to display text, also to display colors, we have seen. So maybe the act of blinking, hello, world, is really just a matter of hiding it, showing it, hiding it, showing it. Maybe there's a way to do that. And indeed there is in CSS. Or maybe it's still there, it's just going black to white to black to white to black to white. So it feels like, so long as I have the ability to kind of sit-in a loop, maybe even an infinite loop if this just keeps going, and every second or so, every half second go ahead and change from black to white, to black to white, or hide show, hide show.

I just need to kind of commingle these capabilities of JavaScript and CSS. And right now I can't stare at this anymore. So let's go ahead and open up blink dot HTML and see how I implemented this. So here's a body tag. Here's a div tag that has unique ID greeting. And then, hello, world as my text. So the HTML to this page is super simple. If I scroll just a little bit, this is why that text is now centered and big. So 96-point, I decided, pretty arbitrarily, just to make big centered text on the screen. What about the JavaScript code? It turns out with JavaScript, just as you can gain access to data in the page, so can you gain access to CSS in the page. And in fact, even though we won't dive in underneath the hood of that library for Bootstrap that made our text fields read, how did it make our text fields read? Well, if we really looked underneath the hood, that library, upon seeing that you didn't type your name or your passwords don't match, it changed underneath the hood the CSS of my web page to go from default colors to red or to green or to whatever.

But how did it do that? Well, it turns out that browsers have the following capability– one, to declare functions. And we know that already. Two, to get elements by their ID. And we know that already. And here I'm just declaring a variable called divs, so my code's a little more succinct. But it turns out that elements on a web page, certainly divs, which are just big rectangular divisions of the page, have a style property associated with them. And a style property, in this case, lines up with that div element, CSS properties, if any. And if I want to change the visibility of this div style, and visibility happens to be a CSS property that we haven't necessarily used, but if you googled around you'd see an online reference of available CSS properties. If the visibility of this element equals equals hidden, I'm going to make it visible.

Else, I'm going to make it hidden. So if visibility is hidden, make it visible. Else, if the visibility is visible, make it hidden. For whatever reason, the opposite of visible in CSS is not invisible. It is hidden, which makes this a bit of a mouthful. But this if block here, this if else, really is just saying, if visible, make it hidden. If hidden, make it visible. So just toggles the state, so to speak, from one to the other. But why would this function operate more than once? There's no loop. There's no for loop, no while loop, no do while loop, nothing. Look at this last line of code. It turns out that in JavaScript you have the ability to do things again and again with a clock that's running inside of your computer, essentially. Window dot set interval is a function you can call in JavaScript that says, hey, browser, call this function every 500 milliseconds. So couldn't quite glean it before visually.

Every half a second, call this function, call this function, call this function. And notice again, as before, when I'm passing around a function by its name, I don't want to do this. If I said, blink open paren close paren, that would call the blink function, and it's only going to call it once. I instead want to pass this function by its name. In C we would call this a function pointer. In JavaScript we call it by reference, passing in the name of this function to set interval. So that set interval knows later what function essentially to append parentheses to, so as to call it every 500 milliseconds. Now how that's implemented, I don't know. I don't care. It's abstracted away from me. But set interval is a function that comes with the browser that probably has some kind of infinite loop that knows to check every 500 milliseconds what's going on underneath the hood.

So this is to say, in JavaScript, we have the ability to control CSS. And indeed, if we now think back retrospectively, that must be how that bootstrap library was doing the form validation and making my fields red when I did something wrong. So you have another feature in JavaScript called local storage. This is relatively newer, but it's a way, on a website, of storing information for the long term, in a user's browser. So in CS50 Finance, and in Web Programming with Flask more generally, we had the ability to store data in sessions. And that's fine. But sometimes it'd be nice to store data locally inside of the user's browser so that you don't have to remember states on the server side. So that you don't have to contact the server to get that information. And so this is particularly common in web applications that you kind of want to be able to run offline. Right. It's increasingly convenient, especially on mobile devices, to be able to run those web pages when you're not connected to the internet, when you're underground or on a plane, so long as you loaded the page in advance.

So with local storage, you actually have exactly that feature in HTML to store information locally. So let's take a look at this page does and then we can deconstruct how it's doing that. If I open up storage dot HTML, notice that it says in the top corner– and I'll zoom in, just the number 0. If I reload, and reload, and reload– and to be clear, all I'm doing is reloading by using my keyboard– and reload, and reload, and reload, the counter is going up. But why is that happening? Well, let me go back into the IDE and focus on these lines of code here. If it's not the case that there is an item called counter in this special global variable called local storage, then you know what, set an item called counter equal to zero. So local storage is really just a JavaScript dictionary– an object that's accessible globally to you. Now we've not seen this before, and it's not all that common to need, but I did it just so I could display something dynamically in the web page. You can call it document dot right, which is similar in spirit to prints in Python or print F in C.

But, again, we don't really print to the screen as much as we change values or HTML as we've done in the past. So we won't really use this too often. But for now, I just want to write local storage dot get items return value when I ask it for counter. But then, and this is the key detail. Every time I print or write that value to the screen, I want to go ahead and reset the item, called counter, to the result of calling parse ent on local storage dot get item dot counter plus 1. So long story short, local storage is going to store key value pairs for you, but as strings. And that's fine, because like quote unquote one, quote unquote two is still useful, but parseInt is a function built into JavaScript that's going to allow me to parse this string that I get back and convert quote unquote something to an actual integer so that I can then add 1 to it and set it back. So this example is only to say, there is an ability to store data locally in the browser. And this is a fundamental alternative, especially for offline mobile apps, to storing data in sessions on the server side.

But things get much cooler, quickly. In fact, let me go into geolocation dot HTML, which creepily wants to know my location. Not my location in the sense of the IP address. I'm seeing the IP address of my computer here. You'll see something with CS50 dot IO or the like most likely. But this is standard prompt that Chrome and Edge and other browsers will trigger if a browser is running JavaScript code that is creepily trying to get your GPS coordinates. So it's a good thing that there's privacy defenses in place. And you really see this on Android and iOS, which don't let apps do anything without your permission typically. But I'm going to go ahead and let it know my location. I'm going to go ahead and click Allow, and see what happens. It's taking a moment. The computer is thinking. I am apparently at GPS coordinate 42.

38 comma negative 77.11. So that's my latitude and my longitude. Now that's not all that interesting unto itself, but let me go to something like maps.google.com. Turns out you can search by latitude and longitude. OK. We didn't have to go very far to triangulate my position there. There we are, roughly in the middle of the building, Sanders Theater here in Cambridge. So that's kind of cool. This is all to say that a browser can apparently infer your location. Now why is that useful? Well if you're building a website that is designed to show maps to the user like Google Maps or MapQuest or Yahoo Maps or Bing Maps or any number of tools, it's kind of a nice feature to just let the user see where he or she is in the world by default, rather than just showing them the generic United States or the whole globe. It'd be kind of nice to at least show them the general area.

And indeed, that's exactly what happened when I went to Maps.Google.com. It knew, within some range, where I was already, even before I typed this in. If you're implementing Yelp or some restaurant review site or something like that where you want to be able to find something near you, it's nice to not have to have me, the human, type in my GPS coordinates, which I certainly would never know. And it's nice to not make me type in Cambridge, Massachusetts or New Haven, Connecticut or whatnot, which is in 06511. Rather just let the browser actually figure out where I am, so long as I consent to actually doing that. I did get that right this time, right? OK. So why is this a useful thing? So this, of course, is useless. Like, who cares what GPS coordinates I'm at? Not all that useful unless you want to target me right now in a map. Rather, we can do something more interesting. So we need the ability to actually get a map. Thus far I have no ability to pull down pictures of maps.

But what if I could make a website, that after downloading some HTML and CSS and JavaScript, what if, ala Google Maps, I could go get maps of Cambridge, go get maps of New Haven or wherever I am in the world and display them to the user. And better yet, what if I could then use the drag event and actually get more of that map– whatever's off the screens above, to the left, to the right, or below me, when that user clicks and drags. Drag being one of the events we can listen for. Well it turns out, as mentioned earlier, that browsers today support AJAX, which is formally called asynchronous JavaScript in XML. But people don't really use XML for this anymore. They use JSON, JavaScript Object Notation. And this is ultimately referring to the ability of modern browsers today, upon already having downloaded a web page and CSS and JavaScript, to make additional HTTP requests from browser to server, without having to reload the whole page, and certainly without the user having to click Reload and then see a big blank screen for a moment, after which they see content. It can all happen dynamically.

So Facebook Messenger, Google Maps, Google Gmail and so forth– any number of websites you use today, certainly the most modern of them, all use this capability. So how do we go about using it? Let me go ahead and open up a file called AJAX 0 dot HTML. And here is now where honestly you want to use something like jQuery. It tends to still be super popular. There's other libraries that can do this for you. But what you don't really want to do is start writing native browser code, so to speak, that's specific to Chrome or specific to Edge or specific to any number of browsers. One of the nicest features about libraries today is that there are so many stupid cross-browser incompatibilities whereby reasonable smart people can disagree, and so different companies have implemented browsers ever so differently in terms of JavaScript, in terms of HTML, in terms of CSS. So literally, you might build a beautiful looking website.

Spend hours and hours getting it to look perfect on your Google Chrome browser, and you open it up in Internet Explorer or Edge or Firefox or Safari, and damn it, it doesn't look right. Something's off aesthetically. It doesn't even work maybe. It doesn't even load. And so a lot of the process of getting websites just right is certainly building them in the first place, but then that last stretch is really about making sure in testing that things work on multiple browsers. So this is all to say, this is when it gets really useful to use something like jQuery, because stuff like AJAX does get relatively simpler as follows. Here is a web page that's including the jQuery library up top. Inside of my own script tag now is a commented function called quote, similar in spirit to what we might have wanted in CS50 Finance if we were using JavaScript at that point. Notice what I'm doing in JavaScript though.

Give me a variable called URL. Set it equal to quote unquote slash quote, which looks like a route, question mark symbol equals, closed quote, plus which is concatenation, the value of the symbol field. Now what is this? Let me fast forward to the HTML down here in AJAX 0. Pretty simple web form and I'm doing it old school here. Form on submit, call the quote function return false. And then have an input whose ID is symbol of type– and it's a little cut off– is text. So what does this page look like? If I go over to AJAX 0, and open this here, it's a very simple web page that simply has a text field with a placeholder that says symbol, and then an HTML submit button that says get quote. But I want this site to do is the following. If I type in GOOG for Google's stock ticker symbol, I want to know right now that it's worth $772.02. If I type in something like Microsoft, that's $59.705. So I'm getting another digit of precision from Yahoo Finance as it turns out, as we'll see.

Netflix, get quote, $123.3405. So in this case we're really getting some additional precision. But all of that is immaterial at the moment. What I really just care about is how this is working. So again, when that form is submitted, the quote function is called. And then it returns false. And that's just so that it doesn't get submitted to a back-end, because there is no back-end at the moment. Rather, I'm using JavaScript to talk to my back-end as follows. Var URL gets this URL equals this value. And this value is whatever the user just typed in. Me, like Google or Microsoft or Netflix. So this a way, notice, of constructing your own path for an HTTP get request. If you think back to week six, we know that you can contact websites ultimately via this route, like slash quote. The question mark is what separates the route from the HTTP query, or the request parameters, the HTTP parameters that you're passing in, one of which I've decided to call symbol.

And now notice what the jQuery library does for us, pretty straightforwardly. jQuery comes with a method called get JSON. Now what is this weird syntax? Again, this is just JavaScript being cool, or jQuery being cool. The dollar sign is literally a synonym for an object called jQuery, a global object that happens to exist because of this line of code. But the author of jQuery, some time ago realized, dollar sign is actually a valid character for a variable name, which is not the case in C. So you know what, I am just going to call my library's global object dollar sign. Why? Well one, it kind of looks cool, but two, it's just much shorter to type. You don't have to actually write out the whole word. But that's all. There's nothing syntactically interesting about this. It's just valid variable symbol. Get JSON does that.

It contacts a server at a certain URL and expects to get back a JSON object, which we saw an example of a bit ago. And what does it do? It will call a function, in this case anonymous, but that's an immaterial detail at this point. And it will pass to that function a reference to the data it gets back from the server. So again, get JSON somehow figures out underneath the hood, how to make an HTTP request to that URL that's passed in as the first argument. And when the server finally replies, this anonymous function is called. It's passed that data. And then we call alert on data dot price. So what is inside of that object? Well I can actually simulate this. Right. If you understand HTTP, you can do all of this yourself. My IP address happens to be on my local machine, 127.0.0.

1. And then I'm on port 80. Your URL might be different, on CS50 IDE. But what I do know is I can construct my own HTTP request by just doing slash quote question mark symbol equals NFLX and Enter. And notice what comes back. If I zoom in on that, this is JSON, JavaScript Object Notation. Why does it look like this? Well, the world just decided, we need a way of standardizing how you get back data. It's useful to get back data in terms of metadata keys, and the actual values you care about. So the world decided that JSON data is going to start with a curly brace, end with a curly brace. It's going to have a whole bunch of key value pairs, which are separated by colons. Each of the values, each of the keys rather, is quoted. Each of the values is quoted if there are strings.

Otherwise if it's a number you can just write it like that. Commas are separating each of those key value pairs. And again, you must use double quotes in this context, which is a long way of saying, this is what my slash quote route returns. This is not a web page. This is not my quote route from CS50 Finance, which was must prettier and it actually had CSS and HTML and it said, a share of Netflix costs such and such. This is just raw data. And this is where AJAX gets compelling. AJAX is the use of raw data like that, you have programmatically requested from browser to server, after the original web page is already loaded, because you want to get more data for the user, perhaps in response, as in this case, to his or her input, like when I typed in Netflix or Google or Microsoft.

This web page isn't all that pretty though, of course. Right. It's ending up just using that alert. And it probably is the case that we can do things a little bit better. And indeed we can. Right now, again, I've kind of regressed. I should not slip into this habit. It's fine for perhaps a lecture demonstration, but let's clean this up right now. If I go into AJAX 1 dot HTML, notice I've gone in and cleaned up my HTML. No longer do I have some hackish call to a function semi-colon return false inside of the value of an HTML attribute. It's just bad design to do that. It's fine to sort of get warmed up. But let's get rid of that, clean up my HTML, and now relegate everything to the top of a file. I'm still using jQuery, but I need one additional line, recall. Now I need this line here. Because a browser reads my code top to bottom, I want to make sure that this code is not executed until the page is ready.

Before, I didn't need to worry about this, because by the time the browser got to my HTML, saw the on click or on submit attribute, rather, and saw the code to execute, that's fine because everything else had already been loaded. But in this case, I have my code up front before the HTML. So I have to say, hey, browser, don't do this, until you're actually ready. What do I want you to do? I want you to, as before, register a submit handler, calling in this function, calling get JSON as before, and then return false here. As an aside, let me point out just one thing. It turns out that putting your JavaScript code in your file, that too is not generally good design. Certainly as your pages get more involved and your code gets more complex, just like in CSS when we factored out our CSS, we should be able to factor out our JavaScript code too. So actually a better practice longer term and certainly with projects would be to do something like this. To take all of this code that I've written, save it in a file called whatever, scripts dot js is perhaps common. And then in my HTML page, don't just have this big open tag and closed tag. Instead, go ahead and say something like this, scripts dot js.

In other words, have a URL or partial URL that says to my browser, hey, browser, besides the page you're currently reading, go get this file as well. Execute any code in there and then proceed to run whatever's inside. All right. But– but, but, but, I bet we can make this even cooler. It is pretty, pretty lame to keep using these alerts. What if instead we had this capability as well. In AJAX 2 we have this example here. Let me go ahead and zoom in. And let me go ahead and type in NFLX for Netflix and click get quote. I don't want that damn alert anymore, which is pretty hackish. And again, it's going to look ugly and different on different browsers. Let me click, get quote. Woo, hoo, hoo. Very nice.

So this time it seems to have embedded the response in the web page itself. And that's going to change GOOG, get quotes, aka Alphabet, or Microsoft, or whatever other company. Somehow we're changing the page. In other words, now we're not just using this out of band alert function. We are changing our DOM. And in fact, let me do this. Let me reload the page to get back to original state. Let me control or right click on Chrome and go into Elements. As you may know here, notice that here in my web page, apparently is a paragraph that we can't see, because it's got no text inside of it. It's just an open tag and a closed tag. But notice the unique ID called quote. And notice what happens.

I'll have to zoom out to see this. But notice what happens. If I type in like GOOG and click, get quote. Don't watch the top. Watch the bottom. A triangle appeared, because now there's something inside of that. So that sentence was dynamically inserted. Let's try this again. Let me try with Microsoft click, get quote, and my page's HTML is changing. And it's also flashing it in purple just so Chrome can draw your attention to it. How about Netflix, get quote. So this is where we're really now tying everything together. We have the ability with JavaScript to get values from this field. We have the ability with JavaScript via AJAX, which is just a use of JavaScript to get more data from the server. We have the ability with JavaScript to change my DOM, my web page, which really just means change the HTML in that page, not permanently.

None of this is happening on the server, these changes here. It's just in my own local browser. And indeed if I reload, the changes go away. But if you think of this sentence here as being like another row in your Gmail inbox, or another message in your Facebook chat window, that's all that's happening. Now I might be just clobbering, that is deleting and changing the previous sentence. But there's nothing stopping me from just writing every individual message to the screen again and again and again. I don't have to overwrite it as I'm doing here. So how do we do this? So if I go ahead and open up now, AJAX 2 dot HTML, it's almost entirely the same as before, except I am now embedding inside of my DOM via these method calls, the actual data I want the user to see. Indeed, this is saying, hey, browser, go get the HTML element whose unique idea is quote.

READ  Anomaly Korea Android on Samsung Galaxy S3 - Androidizen

Call a method associated with that, called HTML, which we haven't seen before. But it just literally changes the HTML of that element to be whatever I pass in as an argument. It's a long argument, but that's just the concatenation of a bunch of strings– A share of, plus data dot name, costs, dollar sign data dot price, period. Now, what is data dot name? What is data dot price? Well data is just the argument to the callback function, which was, again, the anonymous function that I passed in the second argument to get JSON. Data dot name gives me the name therein. Data dot price gives me the price therein. If I really wanted the symbol again, I could do data dot symbol, based on what we've seen inside of that object. But, just like in C, structures, we just use the dot operator in JavaScript to get at the properties of the data inside of an object.

Now again, the only way I would know how to do this with jQuery specifically is by looking up its documentation. And I would know that if I want to get JSON I called dollar sign dot get JSON. I give it a URL, which I've constructed here. And it can be just the relative path if I'm assuming that page is on the same server, that route's on the same server. And then the second argument should be a function. It can be anonymous, doesn't have to be anonymous, doesn't matter so long as that function, per jQuery's documentation takes at least this one argument, which I could called data. I could call it anything else. But the documentation for jQuery says, hey, user, I will pass to this function that I will call back as soon as I have some data for you, whatever the server gives me. And the server has given me a name, a symbol, and a price all inside of this object, this JavaScript Object Notation. Finally, this last line is just kind of nice to have.

I realize, you know what, it'd be a nice feature if after the user searches for a stock quote that we not only see it but we also reset the form to be a blank value. So notice that this symbol refers to a unique element, the unique ID of an element that's not a paragraph tag, as this one is. This is an input field. And input fields don't have HTML inside. They literally just have textual values. So I use dot val instead, passing it in an empty string. But the net effects, notice, this time with that line is the following. Once I've added that line, I have, GOOG, get quote. And notice the field clears itself this time. Once I have Yahoo here, get quote, it clears itself this time. So by adding that kind of line to this example, which just happens to be using a bit more jQuery, I now have the ability to reset the field as well. All right. Now where was that JSON coming from though? Well recall in application dot pie, we had a couple of routes, one of which was register, which was not all that interesting.

It just rendered a template called registered dot HTML. But the other route, which we only glanced at a moment ago, was slash quote. This one's a bit more involved. And I've actually omitted some error checking to keep the code a little tight. You'll see more error checking and more code inside of helpers dot pie from CS50 Finance. But long story short, these five rows of code simply contact Yahoo Finance, passing in that symbol that's been provided, get back the response in CSV, convert the CSV to JSON, and return that JSON. And so this is the code that responds to get requests of the slash quote route, which is what my JavaScript code is using. So again to be clear, we don't have new capabilities necessarily with rendering this financial information that we didn't already have with Python. What has changed is, now I am doing that HTTP request, and I am changing that web page client-side. I'm contacting the server, yes, but only for additional data, only to get that JSON data, only to get the name, the symbol again, and the price. I am not asking the server, hey, server, could you also give me a brand new web page with HTML tags and a body tag and a head tag and a title tag and all that.

I'm not asking the server for a whole darn new page as Jinja might have given me by using a template in, say, CS50 Finance. All I'm asking the server for, is please just give me a stock quote, and I'll take it from there. And so now we have, frankly, a much more responsive interface, because I'm requesting less data of the server. That's going to be a smaller number of bytes, which means it's quicker to send it back to me. And I already know how to display it so there's just a lot less work to do. So in this case, it would seem that the introduction of JavaScript hasn't changed what I can do, but certainly has changed how I can do it. But it's easy to be misled. In our previous examples, when we did some form validation, recall that we could similarly validate that the user typed in the right thing or the wrong thing, client-side, without talking to the server. And the result was prettier for sure. We had a little red text and so forth.

Though technically we could do that server-side as well. It's just easier to do it client-side. But it was faster. I mean, we don't really notice on the wonderful internet speeds we might have right here on campus. But certainly on mobile devices, if I took out my own phone, it's going to feel slower, certainly if you're on a slower connection it will certainly be slower. But it's not sufficient to just get rid of the server altogether and only do client-side. In fact, it turns out, an adversary, whether maliciously or just accidentally, could do something like this. Recall that this form here asked for my email, password, password again, and an agreement. And if I don't cooperate, it yells at me– missing email, missing password, passwords don't match, checkbox unchecked, or whatever. But it turns out that hacking JavaScript, turning it off, is as simple in Chrome or any other browser, poking around your settings, as I'm doing here, scrolling down to an option called, in this case, disable JavaScript. And now after simply disabling JavaScript, woo.

I am registered. Well, not really. But I am not registered. I did not give an email address. I did not give a password. I definitely didn't give it the same password again. And I certainly didn't agree to those terms and conditions. So JavaScript is really just a client-side nicety. It gives us amazing new features. It gives us amazing responsiveness. It is not an alternative to security checks, to validation of data on the server. All of those lines of code from CS50 Finance, all of the lines of code you might have on the server in Python or whatever language that are validating user submissions to make sure they're cooperating, apologizing or admonishing them accordingly, if they don't cooperate are still necessary.

So it's a little annoying that in order to benefit from this client-side responsiveness, this better user experience, you have to now pretty much invent the wheel in two places. In the client-side in JavaScript, on the server in Python or whatever language. But that's the way it is. If you want to achieve the best of both worlds. The security that you get by actually doing something as close to your database as possible on the server, and the nicety that you get, the user experience that you get, and the immediacy of responding to the user by using JavaScript alone. So it turns out, there are some libraries that allow you to, on the server, specify what fields are valid. And you can let the library on the server generate the requisite JavaScript code with which to validate your form. So long story short, thankfully, other people have helped us solve this as well so that you only do need to write the code once if using the right library.

But it's the principle that's important. In fact, too often on poorly written websites, is it possible to circumvent some silly checkbox or some requirements that's not really a requirement. It's really just a JavaScript imposed request for data, if they're not actually validating as much on the server. So realize that that need on the server remains. All right. Back to that map. We have the ability, recall, to get the GPS coordinates of where someone is. We have the ability, with AJAX, to get more data from the server. And though the data we've gotten this far has been stock data, there's nothing stopping us from getting images from the server– more and more images as might composer ultimately a map. And indeed, let me go ahead and open up the following. In map dot HTML is a relatively short page that has a few characteristics. The top of my page. I've got some CSS.

To be cleaner I could factor this out to a separate file but I wanted to keep the demo in lecture pretty succinct. So everything's in this one page. HTML, body and hash map. So the commas in the CSS declaration here just mean, apply the following properties to the HTML tag and to the body tag and to whatever element has this unique ID. I want to make sure all three of those are 100%, because by default your web page has no height. Because if you have no content there's no height. But I want to make sure that my web page literally fills the browser. And I don't want any white margin around the edges. I want everything flush up against the sides and the top and the bottom. So that's all this does for me, nothing more than those aesthetics. Down here, in the body of the page, notice that I have quite simply a div that has nothing inside of it, open tag close tag, but that has unique ID called map. This is really a place-holder where I want to put a map. Down here I have my script tag.

And I could have put this in the head page. Really what I've done is mimic one of the getting started examples in some of Google's online documentation, so that if you'd like to play along further, you'll see that this lines up almost perfectly with some of their getting started exercises. Indeed, even the function name I have here, INET map mimics theirs. And you'll see too, even though in Python, or rather not in Python, in C, we generally put these curly braces on the same line. You'll see that stylistically, probably more common in JavaScript certainly to do it on the same line here, even though the closing brace ends up over here. Again, all that matters is that you are consistent with respect to your own code and nice and neat. So what's going on inside of this INET map function, which I know to implement because Google told me to by reading its documentation. Go ahead and declare a variable called map. Go ahead and instantiats– it turns out that JavaScript allows you to create or instantiate new objects, much like you can in Python. And JavaScript though, in this kind of context, you need to say new, which says to the browser, kind of like malloc, hey, browser, give me memory four– although we're not managing memory like we do at a low level in C for a map.

And Google dot maps dot map, you can think of as a class in JavaScript that represents a map. Like literally a world map. It's not technically a class in this case here, all the newer versions of JavaScript will introduce that and other features. But this is Google's way of allowing me to specify hey, Google, I want to map at the location identified by this unique ID. So document [INAUDIBLE] gets me that div, because its ID was quote unquote map. And hey, Google, here's how I want you to configure that div. I want you to center a world map at this latitude and this longitude– which based on some googling is apparently roughly the middle of the United States, arbitrarily. Zoom level is four. I want to be able to see a lot of the country, not the whole world because then it won't fill the page. But I don't want to just see some middle state for instance.

I want to be zoomed up higher. And I would know what number to use by trial and error or from the documentation. Then I want two markers. I want one marker, one little red pushpin on Cambridge, one pushpin on New Haven. And from some googling, I found that the latitude of Cambridge is roughly 42.3762 and the longitude is negative 71. And New Haven's 41 and negative 72, give or take. And the map I want those markers to be positioned on is map. So map is the key, per the documentation. Map is also the name of my variable. A little confusing, but it also keeps things clean because I mean what I say. So with just these few lines of code, I have implemented a function called INET map, whose purpose in life is to instantiate a map– create a map, and put it in this div. Then with these chunks of code, I'm saying give me a marker, a little pushpin, at this position.

Give me another marker at this position. That's pretty much it. The only other thing I'm doing in this page, notice, is this. At the bottom of the file I have a script tag whose source value is this long URL. It's got a key, which I signed up for earlier. And indeed, if you want to play with this example, you'll have to go to Google's documentation for the JavaScript API– Application Programming Interface– for Google Maps and sign up for your own key, paste it in there so that it actually works. But what's key at the end of this line is this call back. This is just Google's way– it's completely a design decision of their own. But they have configured their documentation and their back-end code base to say this. Tell us the name of your function, because as soon as the Google Maps server hears from you, we will call this function of yours, as soon as the Google Maps API is ready.

And I keep saying API. API is just application programming interface. It's a generic way of saying, someone else has written code that you can use, and the API describes how you use it. Indeed, when I keep saying, I've read the documentation, I've read the documentation, I really read their API or some human-friendly version there of– a user's manual. And for instance, their API prescribes that this special object map it takes in a reference to the elements in which you want to put the map. Then it takes in an object as implied by the curly brace and the curly brace that takes at least these keys, the center of the map, and a zoom level– or at least those are the two keys that I'm using. Meanwhile, the API for Google's marker specifies that you should also pass in an object, per the curly braces, that gives it a map on which to put that marker, that pushpin, and a position at which to put it.

And I'm just doing that twice. So application programming interface will mean a little something different in real terms depending on whether you're using Google or Bing or any number of tools completely unrelated to Maps. But it just refers to features– functionality that someone else has provided that you can then integrate typically into your own program. So what if I now visit Map dot HTML? What do I get? I get a map of the Earth, or of the United States in this case, centered roughly around the middle of your country. And then I have a marker here for Cambridge, a marker here for New Haven. But, notice, this map has so much functionality built into it for free. I can click and drag. And notice– and if you look quickly– well now we are literally over the edge of the Earth. So let's go back.

If you do this quickly, you'll see that those rectangular gray spots appear. And that's because, at that moment in time, Google has not yet downloaded the images, the pings or whatever they are, PNGs for that part of the world. But, notice, if we do this. If I go into my Chrome tools and open up my Developer Tools and watch the Network tab, notice what happens every time I click and drag. Each of those rows in this table at the bottom represents another HTTP request. And a lot of them, notice, are pings. So really useful when developing JavaScript code is to watch the network tab because you can see your own data or someone else's data coming back and forth for you that's then somehow being used by your JavaScript code to update the map. We in our previous example were updating a price and a name of a company on the screen. But in this case, Google is clearly updating images on the screen after having initially drawn these markers. And if I now go to the Elements tab here in Chrome, you'll see that script tag that I had before, and this other script tag, which contains my own JavaScript code.

But notice this. Div ID map, which was previously empty– let me zoom in. If I expand this triangle, apparently inside of that div now is another div. Inside of there is another div. Inside of there is a whole bunch of divs. And indeed, this is what Google's Maps API has done. They have dynamically generated, using JavaScript, all of this HTML. I didn't write any of that. All I gave them was an empty div with a unique ID of ID, and the Google Maps API, upon being told where to put this map, has filled in that blank so to speak with a whole lot more content from its server thanks to JavaScript and thanks to this technique known as AJAX. Meanwhile, we can zoom in and out, because in addition to that drag handler that you see there, there is the plus sign over here.

There's the minus sign over here. There's the satellite map, where it's going to re-download all of the tiles all together. So all of these features– this is my website. Like, I made this. Well, I made this. All I had made was an empty div and maybe a dozen or so lines of JavaScript code. But this is again where programming gets really exciting and really fun, because you can start building things on top of other people's work in a way that they've made available so that you can do this. And if you think about apps you might have in your pocket, Lyft or Uber or the like, those apps have maps built in, right. And Uber probably didn't go around the world with cars or other technologies, figuring out where all the roads are. Rather, they're probably using Google Maps API or something like it, in order to show you those maps. And they built their business on top of that API. And this is again where things get really powerful, really quickly. Now there's another feature still. And just to show you that we're only scratching the surface, let me open up something like this so that we've at least filled in one gap.

Earlier today we started with the alert function, which really should never be used. If you ever see a website that has that ugly alert pop up, that is cutting corners, just as I have because I wanted to focus on the ideas, not on the printing of information. But this underwhelming button at first glance, has actually been implemented using Bootstrap. So that's why it doesn't look like a default button. It's got more of a nicer gray border around it, even though it's still there in the top left-hand corner. But there's an event listener on this button for on click. And when that button is clicked, we're going to see an alert, but it's an alert that's a lot nicer. And maybe it's not perfectly beautiful as you would have it, but it's being generated entirely with JavaScript HTML and CSS. It's not the browsers built-in default. And indeed, notice what just happened.

The back of my screen went kind of gray. There's this nice drop shadow here. There's a title. There's a body. There's a close. And for convenience there's this little x up here. And that's because Bootstrap, the library to which I've been referring, has bunches of other features– not only these things, called modals, which are fancier alerts. And indeed, notice what a modal does. It deliberately, by design, blocks you from seeing other things until you dismiss it. Now it's dismissed itself and it's gone. But these are the kinds of features you get with JavaScript. So form validation, maps, interactivity like that. We're really just scratching the surface. But at the end of the day, it just boils down to a few features. And it's these libraries that take advantage of features like that. jQuery, which you can take a look at in a bit more detail here.

Bootstrap, which again you'll recall from CS50 Finance, but you can see more about it here. It doesn't just come with CSS. It comes now with JavaScript capabilities. And then this is the URL of that other library that uses Bootstrap and gives us form validation. So let's look at one last example so that we can now tie together what we did some weeks ago with what we're now doing in JavaScript. It turns out that in C we of course manipulated images for forensics problems and whodunit and so forth. But you can do this in JavaScript as well. In fact, if you go to this URL here, there's some fun, exercises if you will, from our same friend Nick [INAUDIBLE] from Stanford, whom you may recall starred in that binky claymation video. Well, what Nick has put together online is a bunch of JavaScript examples that give us puzzles like this. So iron image puzzle. So here's something, not just with red noise, but with red and green noise still.

And no matter what angle I look at this one, I really can't tell what it is. And it's not actually one of those magic eye things where you just kind of stare through it and something appears. Rather, there's a lot of noise here. And there's that image hidden. If we actually read the information here, we'll see that it contains an image of something famous. However, the image has been distorted. The famous object is in the red values. However, the red values have been all divided by 10. So they are too small by a factor of 10. So it's like Nick turned a knob and ratcheted down all the red by a factor of 10. The blue and green values are all just meaningless random values, noise, added to obscure the real image. And Nick tells us, you must undo these distortions to reveal the real image. First, set all the blue and green values to zero, to get them out of the way.

Look at the result. And then if you look very carefully you may see the image, although it's very dark. So at which point we can multiply the red values by 10. So let me go ahead and do this. This now is using a simple image API that Nick has provided here. And I know this only from having read through his documentation, poking around the source code and understanding what exists. And I gleaned, by poking around and reading his documentation, that there's at least six functions or methods associated with this simple image API. This API doesn't get more data from the server per se. It's just an API in the sense that it provides me with a set of functions that I can call. So these functions include, get red, get green, and get blue, and set red, and set green, and set blue. And it turns out that Nick's already given me some starter code here in JavaScript. And I can now add some additional code inside of these nested for loops. Because much like your own forensics piece set where you probably iterated from left to right and top to bottom over your image's scan lines and pixels, so can we do the same in JavaScript as follows.

So Nick suggests, and I'll take that advice, that I should first set the green and blue to 0. So I'm going to do IM for image. And that's the variable he's defined up there. And just for good measure you can think of this identical as before. We'll make it just like we did with our variables declarations. Image dot sets green at location x, y to 0. So again, I know the syntax for this API only by having read his documentation. Image dot set blue at location x comma y to 0. And Nick has given me this handy run save button. Let's do that. He is right. So this is another copy of that blue and green image. And I definitely can't really make out the image. I mean, it looks like– there's a little bit of red there. I can actually way up close here– and perhaps on your screen you can see the faintest of red. Let me enhance that.

But the red is there. The information is there. I've set all of the green and blue bytes to 0, but there's still some red. I just need to bump that up. Well let me go ahead and do something like this. Var red equals image to get red at location x,y. All right. So let me do, image dot set red at location x,y, equal to red times 10, as Nick suggests. Click run save. Ho, ho. It's all very red, but now I can clearly see the Eiffel Tower. So we're really just scratching the surface now. I mean there's this whole field of steganography, the art of hiding information within images, for instance. And this is just an example– a simple example at that. But notice the things that we did in C are all the more possible now in Python, or are just as possible if not more possible in JavaScript. But it's ultimately the mental models that are important. There's no server interactivity here once we've downloaded this page. We have been using today, JavaScript entirely on the client side. Which is to say that even once you've download an image, can you permute that image, in memory, in the browser, to manipulate it here.

Or we could have sent it to Python. You could do the exact same kind of thing in Python. Use the appropriate library with extra read, those pixels, and those RGB triples if you will, and do it server-side. So it really just depends on what problem you want to solve. It did JavaScript itself, by a framework called node js can be written on the server-side too. You don't need to use Python or PHP or Ruby or Java or anything. You can use JavaScript. And as an aside, JavaScript has nothing to do with Java. It was really just a marketing ploy at the time. But JavaScript is the programming language that is typically used in the browser. It can be used on the server. And its syntax is exactly what we've seen here today. But it's especially useful in the context of web pages because it gives us a language with which we can manipulate the DOM that we've seen, the tree structure.

It gives us a language with which you can change and add to and remove the HTML, and the CSS, and really anything you see. And indeed, it's this trio of HTML, CSS, and JavaScript, coupled with some back-end, Python or Ruby or PHP or Java or C+ or anything else, that together implement today's web apps. And so now with that, have you the vocabulary, coupled with SQL and your own database back-end to build most anything you want in the world. This was week 10. SPEAKER 2: Like I said, I don't know anything more than you do. SPEAKER 3: There must be something from your grad school days. SPEAKER 4: Hey, man. Not going to the party? We really should get started on that [INAUDIBLE]. It's a doozy. .