UMBC public policy PhD student Del. John A. Olszewski Jr. has announced that he is running for Maryland Senate in what the Baltimore Sun calls “a generational shift in Baltimore County politics.” The Dundalk-area seat he will seek is currently held by Sen. Norman R. Stone Jr., who, at the age of 77, will retire after almost 50 years in office.

Olszewski said, “I’m running so I can be an even more aggressive advocate for the residents of District 6.” He noted, “My experience is that people are looking for common sense solutions to everyday problems. I’m not opposed to working across the aisle if it’s good for the people I represent.”

JavaScript and search engines have always had a tricky relationship, and SEO is often used as an argument against single page applications. I’m aiming to put some of those misconceptions to rest in this article and show you that it’s perfectly possible to create a pure JavaScript web application and still have good SEO.

To demonstrate, take a look at the search results for Monocle, a single page web app. You can see that even though the application relies on JavaScript, articles are still getting fetched and indexed correctly.

While there are indications that Google’s spiders can index some urls they find in JavaScript, in my experience they haven’t been able to render and index complex JS web apps without a little help. The key to spidering JS apps lies in Google’s Ajax crawling specification.

The Ajax crawling specification was originally intended for JS apps that use the hash fragment in the URL, which was a popular technique for creating permalinks when the spec was initially developed. However, we can still use the same spec, with a few tweaks, for modern JS apps using HTML5’s pushState to modify the browser’s URL and history.

Firstly, add the follow meta tag onto every page that needs to be spidered:

<meta name="fragment" content="!">
    

This will instruct Google’s spider to use the Ajax crawling specification with your site. When it sees this tag it’ll then proceed to fetch your site again, this time with the _escaped_fragment_ parameter. We can detect this query parameter, and serve up spider safe content.

You can see an example of this on Monocle, for the index page, and also the post page. As you can see, if the query param is present (and not even set to a value), I serve up raw HTML instead of the JS app.

The code to do so is pretty straightforward. I’m using Sinatra, but the example below should give you a good indication on how to implement this in your framework of choice. I have two routes which are conditional on _escaped_fragment_ being present as a parameter.

helpers do
      set :spider do |enabled|
        condition do
          params.has_key?('_escaped_fragment_')
        end
      end
    end
    
    get '/', :spider => true do
      @posts = Post.published.popular.limit(30)
      erb :spider_list
    end
    
    get '/posts/:slug', :spider => true do
      @post = Post.first!(slug: params[:slug])
      erb :spider_page
    end
    

Make sure that you provide at least a title, meta description, header and text content on each page. Also make sure the meta description matches what you want to be displayed on the search results page.

And that’s all you should need to do. You now have all the user-experience benefits of a JS web application without any of the SEO drawbacks.

One other technique that was pointed out to me was rendering html content straight into a <noscript> tag embedded in the page. I prefer the Ajax crawling spec approach though, as it means you’re not forced to do any SQL requests or rendering unnecessarily for non-bots.

Computer Science and Electrical Engineering
MS Thesis Defense

Multicast Routing with Byzantine Robustness

Debdatta Mukherjee

2:30-4:30 Tuesday, july 23, 2013, ITE 346

Network problems arise when nodes behave in arbitrary ways such as sending malformed messages, sending incorrect messages or not forwarding messages at all to other nodes in the network. These faults are called Byzantine failures. In a real network, these faults can be a result of hardware failure, cyber-attacks or network congestion. Due to the serious problems these faults can cause, it becomes important to make the network robust against them, so that the network continues to operate properly or degrades in an acceptable way in the presence of such faults. In this thesis, we propose methods that include multiple node disjoint path calculations and robust flooding to find byzantine-free multicast trees. By finding such trees, we can guarantee the delivery of the messages from a source to a particular multicast group.

Committee: Professors Deepinder Sidhu (chair), Kostas Kalpakis and Sergei Nirenburg