Week 9, continued

We talked about how web servers send web pages to your browser when they request it. Those web pages are written in a markup language called HTML. CSS is a language that controls aesthetics like font size and color. Ideally, for the sake of reusability and organization, CSS lives in a separate file that gets linked into the HTML. One downside of this approach is that it requires a separate HTTP request to be fetched and thus it might increase latency. Smart browsers will often save a copy of CSS files and other static content locally so that they don’t have to be refetched. This local repository is called a cache and the act of saving to it is called caching.

Unlike HTML, PHP is a true programming language in that it can express logic. When we need our web pages to change their content dynamically, we use PHP to output HTML that the browser then renders. Note that style-wise, we don’t really care about indentation in the HTML, only in the PHP.

Unless you really need to your program to be highly performant, perhaps because your data sets are huge, you’ll probably reach for a language like PHP rather than a language like C. Your C implementation of speller is no doubt very fast, but think how long it took you to program. In contrast, let’s see how easy it is to re-implement the logic in PHP.

<?php
    $size = 0;

    $table = [];

    function load($dictionary)
    {
        global $size, $table;
        foreach (file($dictionary) as $word)
        {
            $table[chop($word)] = true;
            $size++;
        }
        return true;
    }

?>

A hash table in PHP is as easy to implement as declaring an associative array. We can use the words themselves as indices in the array. file is a function that reads in a file and hands it back to you as an array of lines.

A few other details include declaring our variables as globals, stripping the whitespace from the word, and incrementing the $size variable.

Let’s take a stab at check:

<?php
    $size = 0;

    $table = [];

    function check($word)
    {
        if (isset($table[strtolower($word)]))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    function load($dictionary)
    {
        global $size, $table;
        foreach (file($dictionary) as $word)
        {
            $table[chop($word)] = true;
            $size++;
        }
        return true;
    }

?>

All we need to check is if the index for a particular word is set to know whether it’s in the dictionary. size and unload are similarly trivial to implement:

<?php
    $size = 0;

    $table = [];

    function check($word)
    {
        global $table;
        if (isset($table[strtolower($word)]))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    function load($dictionary)
    {
        global $size, $table;
        foreach (file($dictionary) as $word)
        {
            $table[chop($word)] = true;
            $size++;
        }
        return true;
    }

    function size()
    {
        global $size;
        return $size;
    }

    function unload()
    {
        return true;
    }

?>

If it’s this easy to implement this in PHP, why bother implementing it in C? When you run speller in C over the King James Bible, you get a runtime of about 0.5 seconds. When you run speller in PHP over the King James Bible, you get a runtime of about 3 seconds. That’s an order of magnitude difference! One reason is that PHP is an interpreted language, so it has to be read and executed line by line. C on the other hand is already compiled into 0s and 1s by the time it is executed. There are ways to cache the results of the PHP interpreter so that content can be served up faster on the web, but it will likely never compete with C in terms of performance.

There are a number of variables called superglobals that are available everywhere in PHP programs:

A cookie is a long unique identifier that is planted on your computer when you visit a web page, typically via the "Set-cookie" HTTP header. This identifier gets passed back to the web server via the "Cookie" HTTP header when you revisit that web page so that it knows who you are and can serve you content that is specific to you. Think of it like a hand stamp at an amusement park.

We introduced SQL last time as a language to interact with databases. You can think of a database as an Excel spreadsheet: it stores data in tables and rows.

There are four basic SQL commands:

For Problem Set 7, we’ve set you up with a database and an application named phpMyAdmin (not affiliated with PHP) to interact with it. In that database, there is a users table with id, username, and hash columns:

Presumably, username is unique, so why bother with an id column? An id is only 32 bits because it’s an integer, whereas username is a variable-length string. Comparing strings is not as fast as comparing integers, so lookups by id will be faster than lookups by username.

SQL supports the following types:

A CHAR is a fixed-length string whereas a VARCHAR is a variable-length string. It’s slightly faster to search on a CHAR than a VARCHAR.

SQL tables also have indexes:

Adding indexes makes searching a table faster. Because we know that we’ll be using id to look up rows and we know that id will be unique, we can specify it as a primary key by choosing PRIMARY from the Index dropdown menu. Although we decided that id should be the lookup field rather than email, we still want email to be unique, so we choose UNIQUE from the Index dropdown menu. This tells MySQL that the same e-mail address should not be inserted more than once. Choosing INDEX tells MySQL to build a data structure to make searching this column more efficient, even though it’s not unique. Similarly, FULLTEXT allows for wildcard searching on a column.

Databases can be powered by one of several different engines:

This is one more design decision that we have to make, but we won’t trouble ourselves with the particulars for right now.

JavaScript is an interpreted programming language that executes clientside. Whereas PHP is executed on the server, JavaScript is downloaded by the browser and executed there.

If you’ve ever been on page that updates its content without reloading, you’ve seen JavaScript in action. Behind the scenes, it has actually made another HTTP request.

JavaScript is also used to manipulate the DOM, the document object model, the tree of HTML that we saw earlier.

The syntax for conditions, Boolean expressions, loops, switch statements is much the same in JavaScript as it is in PHP and C. One new type of loop exists, however:

for (var i in array)
{
    // do this with array[i]
}

Functionally, this loop is equivalent to the foreach loop in PHP.

The syntax for arrays is slightly different:

var numbers = [4, 8, 15, 16, 23, 42];

Note that we don’t have the $ prefix for variables anymore. We still don’t specify a type for the variable, though.

Another built-in data structure in JavaScript are objects:

var quote = {symbol: "FB", price: 49.26}

Objects are similar in functionality to associative arrays in PHP or structs in C.

JavaScript Object Notation, or JSON, is a very popular format these days. If you work with APIs like Facebook’s for your Final Project, you’ll be passed data in JSON. JSON is quite useful because it is self-describing: each of the fields in an object is named.

Check out geolocation-0.html which seems to know where you are!