In this article, we’ll go over the concepts and techniques required to build a command line tool using Node.js and PhantomJS. Building a command line tool enables you to automate a process that would otherwise take a lot longer.

Command line tools are built in a myriad of languages, but the one we’ll focus on is Node.js.

What We’ll Cover

• Secret sauce
• Installing Node.js and npm
• Process
• Automation
• PhantomJS
• Squirrel
• How it works
• The code
• Packaging
• Publishing
• Conclusion

Secret Sauce

For those short on time, I’ve condensed the core process into three steps. This is the secret sauce to convert your Node.js script into a fully functioning command line tool. But do stick around to see what else I have to show you.

1. In your package.json file, include the following settings:

• "preferGlobal": "true"
• "bin": { "name-of-command": "path-to-script.js" }

The rest of the process is just deciding what functionality to implement.

Installing Node.js And npm

To install Node.js, you have a few options:

• OS-specific installer for Windows, Mac or binary;
• Homebrew: brew install node;
• Nave;
• NVM.

Note that npm is installed as part of Node.js; there is no separate installation.

To test that Node.js and npm are installed correctly, run the following commands in your terminal:

• node --version
• npm --version

Process

Let’s consider a sample process: generating an Application Cache manifest file.

In case you are unfamiliar with AppCache, it enables you to take your application offline by specifying pages and resources to cache in the event that the user loses their Internet connection or tries to access your application later offline.

Typically, you would create an appcache.manifest file, where you would configure the offline settings.

We won’t go into much detail about AppCache itself because that would distract us from the purpose of this article. Nevertheless, below are the lines for a sample file:

    CACHE MANIFEST
    
    CACHE:
    foo.jpg
    index.html
    offline.html
    styles.css
    behaviours.js
    
    NETWORK:
    *
    
    FALLBACK:
    / /offline.html
    

As you can see, we’ve specified the following:

• a JPG image,
• two HTML files,
• a CSS file,
• a JavaScript file.

These are the resources that we want to cache in case the user goes offline.

We’ve also specified that all other items requested by the user should require a network to be accessed.

Finally, we’ve stated that any file that should be cached but isn’t yet should redirect the user to a file named offline.html.

Automation

Having to manually look up all of the images, style sheets, scripts and other pages linked from a Web page would be tedious. Thus, we’re trying to automate the process of generating an AppCache manifest file.

We could do this by writing some Node.js code along with some additional tools, but that wouldn’t be very easy (even for the person writing the script), because we would need to open the code and tell it which Web page to interrogate.

We also want other people to have the benefit of this tool, without their needing to download a folder full of code, change certain lines of code and run commands to run the scripts.

This is why a command line tool would help.

PhantomJS

First, we want to figure out how to solve this problem.

We’ll use a tool named PhantomJS, which is a headless (i.e. chromeless) browser.

Specifically, it’s a headless WebKit browser, which provides a JavaScript API that we can tap into and that lets us do things such as open Web pages and analyze their network requests. (It does many other things, but those are the two fundamental aspects we’re interested in.)

We can use a Node.js module to load PhantomJS and interact with its API. We can then convert our code into a command line tool with relative ease using Node.js’s package manager, npm, and a package.json file.

Squirrel

Luckily, I’ve already done the work for you. It’s an open-source project named Squirrel.

To install it, run the command npm install -g squirrel-js.

Once it’s installed, you can use it by running the command squirrel [url]. For example, squirrel bbc.co.uk/news.

This would generate (in the current directory) an appcache.manifest file populated with all relevant page resources.

How It Works

I started Squirrel by first writing the relevant Node.js and PhantomJS code to incorporate the functionality I was after.

Then, I added a script that bootstraps that code and allows me to take arguments that configure how the code runs.

I ended up with two scripts:

• squirrel.js
• appcache.js

The first script sets up the work:

• We specify the environment in which we want the script to execute (in this case, Node.js).
• Parse the arguments passed by the user.
• Read an internal (i.e. dummy) appcache.manifest file.
• Open a shell child process, call PhantomJS and pass it the script that we want it to execute (in this case, appcache.js) and the dummy manifest file.
• When the second script finishes its work (collating the Web page data), return to this first script and display some statistical information to the user and generate the manifest file.

The second script processes the Web page that the user has requested:

• We take in the dummy manifest file.
• Create listeners for the page resources that are requested.
• Set the viewport size.
• Open the Web page and store the resources.
• Get all links from the page (by executing JavaScript code directly in the Web page).
• Convert the contents of the manifest file and inject the resources found, and then return that as a JSON file.

The Code

Now that you understand what the code does, let’s review it. I’ll show the code in its entirely, and then we’ll go through it piecemeal.

squirrel.js

    #!/usr/bin/env node
    
    var userArguments = process.argv.slice(2); // Copies arguments list but removes first two options (script exec type & exec location)
    
    if (userArguments.length > 1) {
        throw new Error('Only one argument may be specified (the URL for which you want to generate the AppCache.)');
    }
    
    var fs               = require('fs');
    var shell            = require('child_process').execFile;
    var phantomjs        = require('phantomjs').path;
    var scriptToExecute  = __dirname + '/appcache.js';
    var manifest         = __dirname + '/../appcache.manifest';
    var url              = userArguments[0];
    var manifestContent;
    var data;
    
    fs.readFile(manifest, bootstrap);
    
    function bootstrap(err, contentAsBuffer) {
        if (err) throw err;
    
        manifestContent = contentAsBuffer.toString('utf8');
    
        shell(phantomjs, [scriptToExecute, url, manifestContent], function(err, stdout, stderr) {
            if (err) throw err;
    
            // Sometimes an error in the loaded page's JavaScript doesn't get picked up or thrown,
            // but the error comes in via stdout and causes JSON parsing to break
            try {
                data = JSON.parse(stdout);
            } catch(err) {
                log('Whoops! It seems there was an error? You\'ll find the stack trace below.');
                error(err);
            }
    
            displayStatistics();
            createManifestFile();
        });
    }
    
    function displayStatistics() {
        log(''); // Adds extra line of spacing when displaying the results
        log('Links: '      + data.links);
        log('Images: '     + data.images);
        log('CSS: '        + data.css);
        log('JavaScript: ' + data.javascript);
    }
    
    function createManifestFile() {
        fs.writeFile(process.cwd() + '/appcache.manifest', data.manifestContent, function(err) {
            if (err) throw err;
    
            log('\nManifest file created');
        });
    }
    
    function log(message) {
        process.stdout.write(message + '\n');
    }
    
    function error(err) {
        process.stderr.write(err);
    }
    

The first line, #!/usr/bin/env node, is critical to the script being used in the shell. We have to tell the shell what process should handle the script.

Next, we have to retrieve the arguments passed to the command. If we run squirrel bbc.co.uk/news, then process.argv would be an array containing the following:

• the script execution type (node);
• the script being executed (squirrel.js);
• any other arguments (in this instance, only one, bbc.co.uk/news).

Ignore the first two arguments, and store the user-specific arguments so that we can reference them later:

    var userArguments = process.argv.slice(2);
    

Our script only knows how to handle a single argument (which is the page URL to load). The following line isn’t really needed because we’ll ignore any more than one argument, but it’s useful for the code to have clear intent, so we’ll throw an error if more than one argument is passed.

    if (userArguments.length > 1) {
        throw new Error('Only one argument may be specified (the URL for which you want to generate the AppCache.)');
    }
    

Because we’re using PhantomJS, we’ll need to open up a shell and call the phantomjs command:

    var shell = require('child_process').execFile;
    

We’ll also need to reference the bin directory, where the PhantomJS executable is stored:

    var phantomjs = require('phantomjs').path;
    

Next, store a reference to the script that we want PhantomJS to execute, as well as the dummy manifest file.

    var scriptToExecute = __dirname + '/appcache.js';
    var manifest        = __dirname + '/../appcache.manifest';
    var url             = userArguments[0];
    

Because the PhantomJS script that we’ll be executing needs a reference to the dummy manifest file, we’ll asynchronously read the contents of the file and then pass it on to a bootstrap function:

    fs.readFile(manifest, bootstrap);
    

Our bootstrap function does exactly what you would expect: start our application (in this case, by opening the shell and calling PhantomJS). You’ll also notice that Node.js passes the contents of the manifest as a buffer, which we need to convert back into a string:

    function bootstrap(err, contentAsBuffer) {
        if (err) throw err;
    
        manifestContent = contentAsBuffer.toString('utf8');
    
        shell(phantomjs, [scriptToExecute, url, manifestContent], function(err, stdout, stderr) {
            // code...
        });
    }
    

At this point in the execution of the code, we are in the appcache.js file. Let’s move over there now.

appcache.js

The purpose of appcache.js is to get information from the user-requested page and pass it back to squirrel.js for processing.

Again, I’ll show the script in its entirety, and then we’ll break it down. (Don’t worry, we won’t go over each line — only the important parts.)

    var unique     = require('lodash.uniq');
    var system     = require('system');
    var fs         = require('fs');
    var page       = require('webpage').create();
    var args       = system.args;
    var manifest   = args[2];
    var css        = [];
    var images     = [];
    var javascript = [];
    var links;
    var url;
    var path;
    
    bootstrap();
    pageSetUp();
    openPage();
    
    function bootstrap() {
        if (urlProvided()) {
            url = cleanUrl(args[1]);
        } else {
            var error = new Error('Sorry, a valid URL could not be recognized');
                error.additional = 'Valid URL example: bbc.co.uk/news';
    
            throw error;
    
            phantom.exit();
        }
    
        if (bbcNews()) {
            // We want to serve the responsive code base.
            phantom.addCookie({
                'name'  : 'ckps_d',
                'value' : 'm',
                'domain': '.bbc.co.uk'
            });
        }
    }
    
    function pageSetUp() {
        page.onResourceRequested = function(request) {
            if (/\.(?:png|jpeg|jpg|gif)$/i.test(request.url)) {
                images.push(request.url);
            }
    
            if (/\.(?:js)$/i.test(request.url)) {
                javascript.push(request.url);
            }
    
            if (/\.(?:css)$/i.test(request.url)) {
                css.push(request.url);
            }
        };
    
        page.onError = function(msg, trace) {
            console.log('Error :', msg);
    
            trace.forEach(function(item) {
                console.log('Trace:  ', item.file, ':', item.line);
            });
        }
    
        page.viewportSize = { width: 1920, height: 800 };
    }
    
    function openPage() {
        page.open(url, function(status) {
            links      = unique(getLinks());
            images     = unique(images);
            css        = unique(css);
            javascript = unique(javascript);
    
            populateManifest();
    
            // Anything written to stdout is actually passed back to our Node script callback
            console.log(JSON.stringify({
                links           : links.length,
                images          : images.length,
                css             : css.length,
                javascript      : javascript.length,
                manifestContent : manifest
            }));
    
            phantom.exit();
        });
    }
    
    function urlProvided() {
        return args.length > 1 && /(?:www\.)?[a-z-z1-9]+\./i.test(args[1]);
    }
    
    function cleanUrl(providedUrl) {
        // If no http or https found at the start of the URL...
        if (/^(?!https?:\/\/)[\w\d]/i.test(providedUrl)) {
            return 'http://' + providedUrl + '/';
        }
    }
    
    function bbcNews(){
        if (/bbc.co.uk\/news/i.test(url)) {
            return true;
        }
    }
    
    function getLinks() {
        var results = page.evaluate(function() {
            return Array.prototype.slice.call(document.getElementsByTagName('a')).map(function(item) {
                return item.href;
            });
        });
    
        return results;
    }
    
    function writeVersion() {
        manifest = manifest.replace(/# Timestamp: \d+/i, '# Timestamp: ' + (new Date()).getTime());
    }
    
    function writeListContentFor(str, type) {
        manifest = manifest.replace(new RegExp('(# ' + str + ')\\n[\\s\\S]+?\\n\\n', 'igm'), function(match, cg) {
            return cg + '\n' + type.join('\n') + '\n\n';
        });
    }
    
    function populateManifest() {
        writeVersion();
    
        writeListContentFor('Images', images);
        writeListContentFor('Internal HTML documents', links);
        writeListContentFor('Style Sheets', css);
        writeListContentFor('JavaScript', javascript);
    }
    

We begin by using PhantomJS’ API to create a new Web page:

    var page = require('webpage').create();
    

Next, we’ll check that a URL was provided and, if so, clean it into the format required (for example, by giving it an http protocol). Otherwise, we’ll throw an error and stop PhantomJS:

    if (urlProvided()) {
        url = cleanUrl(args[1]);
    } else {
        var error = new Error('Sorry, a valid URL could not be recognized');
        error.additional = 'Valid URL example: bbc.co.uk/news';
    
        throw error;
        phantom.exit();
    }
    

We also put in a check to see whether the URL passed was for bbc.co.uk/news and, if so, use PhantomJS to set a cookie that enables the responsive version of the website to load (the purpose being merely to demonstrate some of PhantomJS’ useful APIs, such as addCookie):

    if (bbcNews()) {
        phantom.addCookie({
            'name'  : 'ckps_d',
            'value' : 'm',
            'domain': '.bbc.co.uk'
        });
    }
    

For PhantomJS to be able to analyze the network data (so that we can track the style sheets, JavaScript and images being requested by the page), we need to use special PhantomJS handlers to interpret the requests:

    page.onResourceRequested = function(request) {
        if (/\.(?:png|jpeg|jpg|gif)$/i.test(request.url)) {
            images.push(request.url);
        }
    
        if (/\.(?:js)$/i.test(request.url)) {
            javascript.push(request.url);
        }
    
        if (/\.(?:css)$/i.test(request.url)) {
            css.push(request.url);
        }
    };
    

We’ll also use another PhantomJS API feature that enables us to determine the size of the browser window:

    page.viewportSize = { width: 1920, height: 800 };
    

We then tell PhantomJS to open the specified Web page. Once the page is open (i.e. the load event has fired), a callback is executed:

    page.open(url, function(status) {
        // code...
    });
    

In the callback, we store the resources that were found, and we call a function that replaces the contents of our string (the dummy manifest) with a list of each set of resources:

    page.open(url, function(status) {
        links      = unique(getLinks());
        images     = unique(images);
        css        = unique(css);
        javascript = unique(javascript);
    
        populateManifest();
    
        // Remaining code...
    });
    

Finally, we create a data object to hold statistics about the resources being requested, convert it to a JSON string, and log it using the console API.

Once this is done, we tell PhantomJS to exit (otherwise the process would stall):

    page.open(url, function(status) {
        // Previous code...
    
        console.log(JSON.stringify({
            links           : links.length,
            images          : images.length,
            css             : css.length,
            javascript      : javascript.length,
            manifestContent : manifest
        }));
    
        phantom.exit();
    });
    

Reviewing the code above, you might wonder how we get the data back to our squirrel.js script? Take another look at the console.log. The code has an odd side effect, which is that any code logged by PhantomJS is passed back to our shell callback (originally executed in squirrel.js).

Let’s revisit our squirrel.js script now.

Back to squirrel.js

    shell(phantomjs, [scriptToExecute, url, manifestContent], function(err, stdout, stderr) {
        if (err) throw err;
    
        try {
            data = JSON.parse(stdout);
        } catch(err) {
            log('Whoops! It seems there was an error? You\'ll find the stack trace below.');
            error(err);
        }
    
        displayStatistics();
        createManifestFile();
    });
    

The callback function is run when the PhantomJS script finishes executing. It is passed any errors that may have occurred and, if there are, then we throw the error:

if (err) throw err;

The other arguments are the standard output and error arguments provided by the shell. In this case, the standard output would be our JSON string, which we console.log’ed from appcache.js. We parse the JSON string and convert it back into an object so that we can present the data to the user who has run the squirrel command.

As a side note, we wrap this conversion in a try/catch clause to protect against Web pages that cause a JavaScript error to occur (the error is picked up by stdout, not stderr, thus causing the JSON parsing to break):

    try {
        data = JSON.parse(stdout);
    } catch(err) {
        error(err);
    }
    

Once we have our data, we call displayStatistics, which uses stdout to write a message to the user’s terminal.

Lastly, we call createManifestFile, which creates an appcache.manifest file in the user’s current directory:

    fs.writeFile(process.cwd() + '/appcache.manifest', data.manifestContent, function(err) {
        if (err) throw err;
    
        log('\nManifest file created');
    });
    

Now that we understand how the script works in its entirety, let’s look at how to allow others to download and install our work.

Packaging

For other users to be able to install our module, we’ll need to publish it to a public repository. The place to do this is the npm registry.

To publish to npm, you’ll need a package.json file.

The purpose of package.json is to specify the dependencies of the project you’re working on. In this instance, it specifies the dependencies required by Squirrel to do its job.

Below is Squirrel’s package.json file:

    {
      "name": "squirrel-js",
      "version": "0.1.3",
      "description": "Node.js-based CLI tool, using PhantomJS to automatically generate an Application Cache manifest file for a specified URL",
      "main": "lib/squirrel",
      "scripts": {
        "test": "echo "Error: no test specified" && exit 1"
      },
      "engines": {
        "node": ">=0.10"
      },
      "repository": {
        "type": "git",
        "url": "git://github.com/Integralist/Squirrel.git"
      },
      "preferGlobal": "true",
      "bin": {
        "squirrel": "lib/squirrel.js"
      },
      "dependencies": {
        "phantomjs": "~1.9.2-6",
        "lodash.uniq": "~2.4.1"
      },
      "keywords": [
        "appcache",
        "phantomjs",
        "cli"
      ],
      "author": "Mark McDonnell  (http://www.integralist.co.uk/)",
      "license": "MIT",
      "bugs": {
        "url": "https://github.com/Integralist/Squirrel/issues"
      },
      "homepage": "https://github.com/Integralist/Squirrel"
    }
    

You can read up on all of the properties of package.json in the npm registry.

The properties to note are these:

• "preferGlobal": "true"
• "bin": { "squirrel": "lib/squirrel.js" }

The first property indicates when a user has installed a module that you would prefer to be installed globally. In this case, we want it to be installed globally because then the user will be able to run the command anywhere in their system.

The second property indicates where the command will find the code required to execute the command.

To test that your command works, you’ll need to run the npm link command, which in this case creates a symlink from the squirrel command to the squirrel.js file.

Publishing

To publish your code, first register for an npm account.

You’ll need to verify the account via the command line. To do this, run npm adduser, which will ask you to specify a user name and password.

Once you’ve verified the account, you can publish your module to the npm registry using npm publish.

It could take a few minutes for the module to become publicly accessible.

Be aware that if you update the code and try to run npm publish without updating the package.json file’s version property, then npm will return an error asking you to update the version number.

Conclusion

This is just one example of the sort of command line tools you can develop with Node.js’ many features.

The next time you find yourself performing a repetitive task, consider automating the process with a CLI tool.

(al)

© Mark McDonnell for Smashing Magazine, 2014.

Making a Mark

A UMBC mathematician finds the right equation for biologists

Kathleen Hoffman, a professor of mathematics and statistics at UMBC, works in math biology, but she often felt that her biology colleagues didn�t really understand what she was doing.

�The work I did was very foundational in mathematics and it didn�t really help them design an experiment or impact their way of thinking,� Hoffman says. So after she got tenure, Hoffman did something most mathematicians wouldn�t think of doing: she took a sabbatical, got funding from the National Science Foundation and joined a biology lab.

�I called it an immersion program,� says Hoffman, �because what I wanted to do was like learning a new language, where you just go to the country and live there, and that�s what I did.�

Hoffman had done her homework. She knew she wanted to work with Avis Cohen, a professor of biology at the University of Maryland, College Park who researches lampreys � a kind of a jawless fish that sucks the blood out of other fish � and how they swim. Scientists study lamprey locomotion because these fish possess neurons similar to those that power human locomotion, but thousands and thousands of orders of magnitude fewer in number � and thus much easier to study.

Joining Cohen�s lab brought about a fundamental change in Hoffman�s research, introducing her to an interdisciplinary group of mathematicians, biologists, and engineers all working on lampreys. �We had the best meetings,� says Hoffman, �because we were such an interdisciplinary group and it was predominantly women, which is very unusual in mathematics.�

Hoffman�s task was to mathematically model neurons. �The model pushes you in the right direction experimentally,� she explains. In developing the equations for the model, however, Hoffman had to grapple with lamprey biology.

�You don�t know what you�re trying to model if you don�t understand the biology,� she says. �But I wouldn�t say I sit down and understand the biology and then start writing math. It�s a process. I understand a little bit of the biology, and then I do a little bit of the math, and then I go back.�

One colleague says that Hoffman�s work modeling work is critical for the biologists and other researchers on the team to understand locomotion and design their experiments. �The problem of locomotion is difficult to understand without mathematics,� says Tim Kiemel, a research assistant professor in the department kinesiology at the University of Maryland, College Park.

Hoffman eventually needs the power of computing to actually �do� the modeling. But before she dives into programming, she starts out using a pencil and paper to define the problem and pose the right questions.

�Sometimes you just have to sit there and stare at it,� Hoffman says. �Sometimes you have to do a lot of calculation, or sometimes you just have to let it stew.�

(02/07/14)

Planting a Seed

New grants grow UMBC�s research partnership with UMB

Faculty members at Maryland universities conduct important research that may provide relief for spinal cord injury victims, or develop new targeted methods to deliver drugs through nanotechnology.

More and more of that vital work is being conducted in collaborations between faculty at UMBC and the University of Maryland, Baltimore (UMB).

The latest venture to expand the research partnership between the two neighboring universities (separated by less than seven miles) is a joint UMBC-UMB Research and Innovation Partnership Seed Grant Program that pairs primary investigators from each university to conduct research as a team. Successful partners are offered research funding of up to $75,000 over twelve months to pursue their collaboration.

The program�s first grant recipients were announced at a ceremony and poster session held at UMBC�s Albin O. Kuhn Library on February 11, 2014. Those selected for the awards included faculty in UMBC�s College of Natural and Mathematical Science and College of Engineering and Information Technology, as well as researchers in the University of Maryland School of Medicine and University of Maryland School of Pharmacy.

At the announcement ceremony, UMB Chief Academic and Research Officer and Senior Vice President Bruce Jarrell observed that the Seed Grant Program represents the deepening of a relationship that already includes cooperation on a joint graduate school and the Institute of Marine Environmental Technology (IMET) as well as a panoply of curricular efforts in areas such as the life sciences, gerontology, health informatics and social work.

�These collaborations already exist,� Jarrell observed. �And we�re proud to have UMBC as a partner.�

UMBC President Freeman A. Hrabowski, III, is enthusiastic about the projects selected for the initial round, which include investigations that may influence the course of research into cancer, strokes and muscle degeneration.

�The Seed Grant Program is a means by which both universities can better discover each other�s strengths and needs to see how we can better collaborate,� says Hrabowski.

Jay Perman, President of the University of Maryland, Baltimore, says increased partnership between the two universities is a key element of his vision. �I cannot stress enough the importance we place on our collaborative relationship with our colleagues at UMBC. The partnerships that UMBC and UMB have enjoyed for years are real, longstanding collaborations, and have been extremely successful, if not widely known.�

At the state level, the research partnerships fostered by the Seed Grant Program will further extend Maryland�s research profile and aid in securing vital funding from federal agencies, private foundations and other funding sources.

William E. Kirwan, Chancellor of the University System of Maryland (USM), praises the new program for its �focus on cutting-edge science and health concerns� and its emphasis on interdisciplinary teamwork.

�It is this type of structured collaboration.� Kirwan says, �that will enable both UMBC and UMB�as well as the USM�to reach their full potential, and to take full advantage of the opportunities before us.�

The first five teams to receive UMBC-UMB Research and Innovation Partnership Seed Grants are:

* Kathleen Hoffman, professor of mathematics (UMBC) and Asaf Keller, professor of anatomy and neurobiology (UMB), are exploring the chronic pain of patients with spinal cord injury and how computational modeling may help analyze the neurobiological changes in the central nervous system after such injuries.

* Martin Schneider, professor of biochemistry and molecular biology (UMB) and Bradford E. Peercy, assistant professor of mathematics (UMBC) are combining forces to analyze a transcription factor (Foxo1) in skeletal muscle that activates genes in a pathway that leads to the breakdown of muscle protein. They hope to develop protocols and models that will provide new approaches to controlling this factor.

* Charles Bieberich, professor of biological sciences (UMBC) and Paul Shapiro, associate professor of pharmaceutical sciences (UMB) are working on a more targeted use of a promising cancer treatment called �kinase inhibition.� Currently kinase inhibition creates resistance over time, so Bieberich and Shapiro are looking for more selective paths to inhibit portions of an enzyme that allows cancer cells to multiply without shutting down other functions in the process.

* Marie-Christine Daniel, associate professor of chemistry and biochemistry (UMBC) and Peter Swaan, professor of pharmaceutical sciences (UMB) are exploring how nanotechnology might improve the delivery of drugs (increased dosage, or better targeting) by examining a class of molecules known as �dendrons.�

* Tulay Adali, professor of computer science and electrical engineering (UMBC) and Kelly Westlake, assistant professor of physical therapy and rehabilitation science (UMB) are exploring how using a powerful computational tool (independent vector analysis) can aid in navigating variability in cognitive neural function and better help the recovery of stroke victims.

A call for proposals for the next round of the UMBC-UMB Research and Innovation Partnership Seed Grant Program will be issued on April 15, 2014.

(02/12/14)

In this tutorial we’re going to look at how to speed up the user experience on small static sites using a few different methods. (A static site is one which doesn’t have any renewing content, so no blog posts or photo streams etc.)

The way we’re going to be doing this is by taking out page reloads. So simply put, when the user uses some navigation links, only the main content of the page changes and it doesn’t make the browser reload the page.

We will be achieving this effect in two different ways, the first only uses jQuery, and the other uses AJAX and some PHP. They both have their pros and cons, which we’ll look at as well. Take a look at the demo to see what we’re trying to achieve and let’s start with the first (and simpler) jQuery method.

Achieving the effect with jQuery

First we will look at the setup for the page. The HTML is very simple but has a few important parts, “the essentials” as it were. We need some navigation links which have a specific hash href (which we’ll explain in a minute) and a specified content area which you would already have on any other site anyway. So let’s first see what is in our index.html file:

<body>
<header>
 <h1>Speed Up Static Sites with jQuery</h1>
 <nav>
 <ul>
 <li><a href="#page1" class="active" id="page1-link">Page 1</a></li>
 <li><a href="#page2" id="page2-link">Page 2</a></li>
 <li><a href="#page3" id="page3-link">Page 3</a></li>
 <li><a href="#page4" id="page4-link">Page 4</a></li>
 </ul>
 </nav>
</header>
<div id="main-content">
 <section id="page1">
 <h2>First Page Title</h2>
 <p>First page content.</p>
 </section>
 <section id="page2">
 <h2>Look, no page load!</h2>
 <p>Second page content.</p>
 </section>
 <section id="page3">
 <h2>Ooh fade!</h2>
 <p>Third page content.</p>
 </section>
 <section id="page4">
 <h2>Fourth Page Title</h2>
 <p>Fourth page content.</p>
 </section>
</div> <!-- end #main-content -->
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script&gt;
<script type="text/javascript" src="custom.js"></script>
</body>

So to recap the important parts of what needs to go into the markup: we have our navigation in which each link has an href of the corresponding DIV. So the link to “Page 2″ has a href=”#page2″ (which is the id of the <section> element further down). So with this first method as you can see we have a div of #main-content surrounding our sections, and then each page content one after the other in their own separate ‘section’ element. We also call jQuery and our own custom.js javascript file in which the actual functionality of the site will be made.

But before we get to that we need to add one line to our CSS, there’s no need to go over the whole CSS file for this example as it’s all only for looks, which will change with whatever project you’re working on. However, with this first method there’s one line that’s essential and that’s:

#page2, #page3, #page4 {
display: none;
}

This hides all the ‘pages’ except the first one. So the page appears normally on first load.

The JavaScript

So now to explain what we need to achieve via jQuery. In our custom.js file, we need to target when the user clicks on a navigation link. Retrieve its href link and find the ‘section’ with that same ID, then hide everything in the #main-content div and fade in the new section. This is what it looks like:

$(function() {
    $('header nav a').click(function() {
        var $linkClicked = $(this).attr('href');
        document.location.hash = $linkClicked;
        if (!$(this).hasClass("active")) {
            $("header nav a").removeClass("active");
            $(this).addClass("active");
            $('#main-content section').hide();
            $($linkClicked).fadeIn();
            return false;
        }
        else {
            return false;
        }
    });
    var hash = window.location.hash;
    hash = hash.replace(/^#/, '');
    switch (hash) {
        case 'page2' :
            $("#" + hash + "-link").trigger("click");
            break;
        case 'page3' :
            $("#" + hash + "-link").trigger("click");
            break;
        case 'page4' :
            $("#" + hash + "-link").trigger("click");
            break;
    }
});

This code is split into two sections, the first achieves what we just talked about. It has a click function on the header nav links. It then puts the ‘#page1, #page2′ etc into a variable named $linkClicked. We then update the browser’s URL to have that same hash name. Then we have an if statement making sure the link we’re clicking is not the current tab, if it is then do nothing, but if not hide all current content and unhide the div with an ID of $linkClicked. Simple as that!

The second section checks if the url has a hash link on the end of it, if it does, it finds a corresponding link on the page with the same value (that’s why the links have specific IDs in the markup) and then it triggers that link (it clicks on it). What this does, is means the user can reload a page after having navigated to a ‘page’ and the refresh will send the user back there instead of just back to the first page, which can often be a problem with this sort of system.

So that’s the end of the first method, this results in a working static site that has instantaneous content swapping, and no page reloads. The only drawback to this method is the fact that all the content is called on the initial load, as it’s all there in the index file. This can start to be a problem with photos and extra content making the first site visit load a bit longer. So let’s look at another way to do this same effect which can eliminate that problem.

Using AJAX and PHP

To achieve this same effect but in a slightly different way, so that the initial load isn’t going to load all of our content and thus slow it down (defeating the point if the site has a lot of content) we will use a little PHP and AJAX. This means that the file structure for our project will change and look like this:

So if you look, the index file is now a .php and not a .html. We also have an extra file named ‘load.php’ as well as a new folder/directory called pages in which there are four HTML pages. Now this means that if you’re working locally you need to set up a local development environment using something like MAMP (for Mac) or WAMP Server (for Windows). Or you can upload the whole folder onto a web server if you have access and edit on there, basically you’ll need an environment where the PHP will work.

The index.php has only changed one thing, but it’s important, we will now not load all the content in there, and simply call the initial content in with a PHP include. It now will look something like this:

<body>
<header>
 <h1>AJAX a Static Site</h1>
 <nav>
 <ul>
 <li><a href="#page1" class="active" id="page1-link">Page 1</a></li>
 <li><a href="#page2" id="page2-link">Page 2</a></li>
 <li><a href="#page3" id="page3-link">Page 3</a></li>
 <li><a href="#page4" id="page4-link">Page 4</a></li>
 </ul>
 </nav>
</header>
<div id="main-content">
<?php include('pages/page1.html'); ?>
</div> <!-- end #main-content -->
<script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.7.2/jquery.min.js"></script&gt;
<script type="text/javascript" src="custom.js"></script>
</body>

So the line beginning <?php is calling in the first HTML file from our folder of pages and inserting in entirely into our #main-content DIV. The file called can contain whatever content you want to appear on the page.

Using $.ajax in the JavaScript

Let’s move onto the new JavaScript, it now looks slightly different, mainly we’re now using AJAX to fetch the new content from each HTML file when the user clicks on some corresponding navigation. Here’s the first function in the code (the second stays the same as before):

$(function() {
    $('header nav a').click(function() {
        var $linkClicked = $(this).attr('href');
        document.location.hash = $linkClicked;
        var $pageRoot = $linkClicked.replace('#page', '');
        if (!$(this).hasClass("active")) {
            $("header nav a").removeClass("active");
            $(this).addClass("active");
            $.ajax({
                type: "POST",
                url: "load.php",
                data: 'page='+$pageRoot,
                dataType: "html",
                success: function(msg){
                if(parseInt(msg)!=0)
                {
                    $('#main-content').html(msg);
                    $('#main-content section').hide().fadeIn();
                }
            }
        });
    }
    else {
        event.preventDefault();
    }
});

So let’s explain what’s going on. We’re adding one more variable, that’s $pageRoot. This is basically the actual number clicked (taking way the ‘#page’ part of the hash link and leaving the individual number). Then inside the same “if” statement as before we call ajax and use the other PHP file we mentioned earlier to parse the information given (which link has been clicked) and find the corresponding page. Then if it comes back with no error, we insert the new HTML from the file received into our #main-content DIV. Then just to stop it changing suddenly, we hide everything and then fade it in.

load.php

The contents of the new PHP file is short and sweet, it takes the page number that jQuery has sent it and looks to see if the corresponding HTML file exists. If it does it gets all the content and returns it to the AJAX function (which we showed a moment ago that we insert that content into the main DIV).

<?php
if(!$_POST['page']) die("0");
$page = (int)$_POST['page'];
if(file_exists('pages/page'.$page.'.html'))
echo file_get_contents('pages/page'.$page.'.html');
else echo 'There is no such page!';
?>

Following that the site should look however you want it to, but mostly work properly.

That’s it! The site now calls in the right corresponding HTML file each time the user clicks on a navigation link. It swaps out the content without making the page reload. And this way it still doesn’t have to call all the content on the initial page load! I hope you’ve managed to learn some useful method from this tutorial and that you can use it to improve some project in some way.

You can view the jQuery demo here, the PHP demo here, or download the source and take a closer look.

Have you used AJAX for loading content? Have you used a similar technique to speed up your site? Let us know your thoughts in the comments below.

Featured image/thumbnail, supercharged image via Shutterstock.

Create Picture-Perfect Portraits With Beautune – only $14!

Would you let a startup track your social media accounts and credit-card transactions in exchange for cash?

A startup called Datacoup is far from the only tech company hoping to get rich by selling insights mined from your personal data. But it may be the only one offering to give you money for that information.

By Ms. Katarzyna Wac

Abstract Increasingly, we use mobile applications and services in our daily life activities, to support our needs for information, communication, leisure, or even health and care needs. However, user acceptance of a mobile application depends on at least two conditions: the application's perceived experience, and the appropriateness of the application to the user's context and needs. However, we have a weak understanding of a mobile user's quality of experience (QoE) and the factors influencing it. In my talk i discuss a 4-week-long 29-Android-phone-user study, where we collected both QoE and the underlying network's quality of service measurements through a combination of user, application, and network data on the user's phones. We aimed to derive and improve the understanding of users' QoE for a set of widely used mobile applications in users' natural environments and different daily contexts. I present data acquired in the study and discuss implications for mobile applications design, especially those in mobile health domain. I propose a framework for assuring the user's experience for these applications.

Bio: Ms. Katarzyna Wac is a senior scientist (fr. "MER") at the Institute of Services Science (ISS) of University of Geneva (UniGE) and leader of the Quality of Life (QoL) research area since 2010. She holds a BSc and MSc degree in Computer Science from Wroclaw University of Technology (WUT, Poland), an MSc in Telematics from University of Twente (UT, the Netherlands), as well as a PhD in Information Systems from University of Geneva (Switzerland). In 2003-2004, Ms. Wac was a research staff member at University of Twente. In 2005 she joined University of Geneva as a research and teaching assistant, while keeping her affiliation with the University of Twente. In 2007-2010, Ms. Wac was also affiliated with the MobiHealth BV start-up company. In 2009-2010, Ms. Wac was on leave for a one-year Swiss NSF Fellowship at Carnegie Mellon University (CMU, USA), Human-Computer Interaction Institute (HCII). Along the summer 2013, Ms. Wac was supported by Swiss NSF International Visits program to research at Stanford University (Stanford, USA), and particularly at the Stanford Human-Sciences and Technologies Advanced Research Institute (H-STAR). Ms. Wac's research interests include Quality of Service-aware mobile systems and services with special emphasis on support of adaptive multimedia protocols and Quality of Service mechanisms, especially in the mobile healthcare (i.e., mHealth) domain. Ms. Wac strives towards effective and efficient pervasive mobile computing and communication - meeting the end-user Quality of Service requirements and Quality of Experience expectations. Ms. Wac is since 2012 an Associate Expert of the International Telecommunication Union (ITU) European Regional Initiative for mHealth.

It’s Tuesday which means that the Treehouse Show is back! In episode 77 of The Treehouse Show, Nick and Jason (@jseifer) talk about Sass mixins, JavaScript coding, git tips, and much more.

This Week’s Links

• Z63 | 8 Sass mixins you must have in your toolbox

• Firefox Notes – Desktop

• Sass: Mixin or Placeholder?

• A re-introduction to JavaScript (JS Tutorial) – JavaScript | MDN

• carrot/share-button

• Git tips from the trenches

• A List Apart Pattern Library

The post Sass Mixins, JavaScript Coding, Git Tips | The Treehouse Show Episode 77 appeared first on Treehouse Blog.

Here’s a tricky one for you…can genetic guys use girls’ bathrooms?

This very question was recently contested in the courts of Maine, where the highest court ruled that a biological male, who has identified as a female for most of her life, may use the women’s restroom instead of the men’s.

The court further held that preventing her from using the women’s bathroom was discrimination, and a violation of her rights.

 Critics have complained that this move is impossible to enforce. Can a guy suddenly decide to “identify” as a girl just to get into the girls’ restroom?

Where do schools draw the line between who is, and who is not, allowed in a restroom? While the court stressed that males should not be “casually” granted access to women’s facilities, the question of who can use the women’s bathroom is still very unclear.

Maybe your thoughts on this are clearer… What do you think about this new commotion in the commodes?