Javier Tordable Blog

Really Simple SEO

Fri, 12 Mar 2010 00:36:31 GMT

SEO stands for Search Engine Optimization, and is the process of improving a website's structure and content in order to make it easy for search engines to gather the pages and display them in search results in the best position possible.

In this post I am going to explain a few basic principles of SEO and show examples of how I implemented them in my blog. Also, as I am the Tech Lead of Webmaster Tools backend, I am going to talk a little bit about some features of Webmaster Tools that are very helpful for SEO. Please remember that all these tips are not only good for search engines, but also for users. If you have to choose between doing something to benefit users or search engines, always choose what is best for users.

Here is the list of simple SEO tips:

Use a good URL structure, with descriptive URLs. If the URL has keywords related to the page topic it will be easier to find in search results. For example, the url of this post includes the words really simple seo, that are the topic of the post
```
 
    http://www.javiertordable.com/blog/2010/03/11/really-simple-seo
  
```
Use good page titles. Similar to the previous tip, good page titles, with appropriate keywords make it easier to find the page in search results. Even though the title of this page includes the full name of the site, the title begins with a good description of the content
```
 
    Really Simple SEO - Javier Tordable blog on Software, Mathematics and
    Technology
  
```
Have a good meta description for each page. The meta description is used by some search engines to show in the snippets in search results (the small paragraph with a description of the page). If you don't use it, you will have the risk that the search engine will generate it by itself, with unexpected results. This happened to me before I had a meta description, my snippet was taken from the RSS feed and looked awful. My current meta description for the homepage is:
```
    <meta name="description" content="Javier Tordable blog on Software,
    Mathematics and Technology. Javier Tordable is a software engineer at
    Google and Ph.D. candidate in Mathematics.">
  
```
Structure the page appropriately, using HTML header tags. The most important parts should be within a H1 tag, the second most important in H2, etc. until H6. For example in this post the blog title and subtitle are within H1 and H2 tags. The title of the particular post is in a H2, and other less important sections, the about box and the archives are within an H3 HTML tag
```
 
    <h1><a href="/">Javier Tordable</a></h1>
    <h2>A blog on Software, Mathematics and Technology</h2>
    <h3>About</h3>
    <h3>Archives</h3>
    <h2>Really Simple SEO</h2>
```
Use the simplest format possible. Currently search engines are very advanced and can process Flash, Javascript and other content types, however it's always easier to access raw HTML content. So prefer to use HTML for most content, unless Flash or Javascript are essential. Also it will be easier to access the page from old browsers or other platforms. For example iPhone users can't see Flash pages
Have a flat internal link structure. The flatter your link structure is, the easier it will be for search engines to access a page. Also the easier it will be for users to access whatever content they are looking for. In my blog I have all the main sections linked in the top navigation bar, which appears in all pages. And in the right side of most pages there is a link to all the blog posts
```
 
    <a href="/blog/all">All Posts</a>
  
```
From the homepage of the site it's possible to access any other content page in two clicks or less.

And now, some interesting pieces of information about your site that you can find in Webmaster Tools:

One of my favorites is Backlinks, which will show you all the links pointing to your site, from all over the Web. Having many quality links is important because it will be easier for people to find your site, and it will show to search engines that the site is relevant.
Another very useful tool is Top Search Queries, which will show for which queries my site appears in search results. For example, the "bundle adjustment" query has more requests than "javier tordable" and it appears in the second row in the following table, while the other query is in the third row. However my site appears in position 16 for bundle adjustment, and it appears in position one for searches of my own name
Also, another cool piece of information is Subscriber Stats which shows how many subscribers I have for my RSS feed from Google Reader. In my case I can see that I have 10 people subscribed. And I can also submit this feed as a Sitemap, which will help getting my site indexed For example, my Sitemap statistics show that I have 11 pages in this sitemap, and they are all indexed
And to check that my site is being correctly crawled, I can check the Crawl Stats feature. As you can see in the graph, the number of pages that are crawled in my site per day has been going up significantly since I implemented all this SEO tips

To finish, I am just going to point out that there are a lot of SEO resources online. Doing proper search engine optimization doesn't need to be complicated or expensive. And is not only good for search engines, but also for users. For more tips, you should check the Google SEO guide.

Collaborative Mathematics and The Future of Science

Thu, 25 Feb 2010 20:02:55 GMT

Mathematical research is traditionally seen as a one-man job. To quote Jean Dieudonné in The Music of Reason:

Research in the experimental sciences is done in laboratories, where larger and larger teams are needed to manipulate the instruments and to scrutinize the results. To do research in mathematics nothing is needed except paper and a good library. Team-work, as practiced in the experimental sciences is, then, quite unusual in mathematics, most mathematicians finding it difficult to think seriously except in silence and solitude. Collaborative work, while quite common, most often consists in putting together results that each of the collaborators has managed to obtain in isolation, albeit with mutual profit from each other's ideas, enabling them to progress form new points of departure.

In spite of that, about a year ago Tim Gowers asked himself if it would be possible to solve important mathematical problems by collaborating openly over the internet. Not a collaboration among a few colleagues, but among everybody that had any insight about the problems. He shared this question with the mathematical community through a post in his blog. That was the birth of the Polymath project.

The first problem that the Polymath group worked on is the attempt to obtain a simple proof for the Hales–Jewett theorem. This theorem is a very important result from Ramsey theory. In very gross terms Ramsey theory says that for many mathematical structures, there is no such thing as complete randomness.

For example, take a group of six people: Alice, Bob, Charles, David, Erin and Fritz. The Ramsey theorem tells us that there are either 3 people that all know each other, or 3 people that are all strangers to each other. Even in something as random as a party, if there are at least 6 people then we can find a very special subgroup of 3 people.

Here is the proof: Take Alice, imagine that she knows less than 3 people at the party. That is, she knows only Bob, or knows only Bob and Charles. Then we consider David, Erin and Fritz. If they all know each other, we have a group of 3 people that know each other. If not, two of them don't know each other, for example David doesn't know Erin. As a consequence Alice, David and Erin are all strangers to each other. If Alice knows 3 people or more, the proof is the same, say she knows Bob, Charles and David. If none of them knows each other then there we have our group of 3 strangers. But if two of them know each other, for example Bob knows Charles, the group Alice, Bob and Charles all know each other.

So far the Polymath group has discussed 5 problems, which are all shown in the Wiki and they have started to publish some of the results. Here is link to a paper from D.H.J. Polymath on arXiv, A new proof of the density Hales-Jewett theorem.

The following image is a part of a 3D Maldelbrot fractal, as described here. It has nothing to do with the rest of the post, but the Hales-Jewett theorem doesn't lend itself easily to fancy pictures.

And for comparison purposes this is a piece of romanesco broccoli.

Of course, Mathematics is not the only scientific discipline in which people collaborate openly in interesting problems. Michael Nielsen has a great blog post about doing science online. Probably the most important point is that the way that scientists work with each other is changing. And the change is driven mostly by new online collaboration tools. To finish the post I will quote Michael:

Blogs, wikis, open notebooks, InnoCentive and the like aren’t the end of online innovation. They’re just the beginning. The coming years and decades will see far more powerful tools developed. We really will enormously scale up scientific conversation; we will scale up scientific collaboration; we will, in fact, change the entire architecture of expert attention, developing entirely new ways of navigating data, making connections and inferences from data, and making connections between people.

New Google Chart Tools

Wed, 17 Feb 2010 02:03:13 GMT

Google recently released a new set of tools for graphics and interactive visualizations called Google Chart Tools. Google Chart Tools replaces the previous Charts API (for static images) and Visualization API (for dynamic graphics). And it combines both APIs within a single framework. Here is a link to the official announcement.

This is an example of the Charts API, a map with a couple of countries marked in a different color:

This map was generated with the following link:

http://chart.apis.google.com/chart?cht=t&chtm=world&chs=440x220
&chld=USES&chd=t:10,50&chco=FFFFFF,00FF00,005500&chf=bg,s,EAF7FE

Let me go over each part in that link and explain what it means:

cht=t indicates that this is a graph of type map
chtm=world says that the map should include the whole world
chs=440x220 is the size of the chart
chld=USES is the list of countries to display in a different color, US and ES
chd=t:10,50 is the intensity of the color of each country. US=10, ES=50
chco=FFFFFF,00FF00,005500 is the color gradient FFFFFF=white for the background, 00FF00 light green (US) and 005500 medium green (ES)
chf=bg,s,EAF7FE is the background color, light blue

Here is another example, but this time of an interactive visualization:

In this case the map is dynamic. Moving the mouse over the different countries will display a message, which contains the value used to select the color of the country. Now the code is a little bit longer, about 30 lines of Javascript, so I am not going to include it, but there is a detailed explanation here: Google Chart Tools, Introduction.

These tools are probably not as powerful as custom made visualizations, like the ones that I talked about in a previous post, Interesting Visualizations: Changes Over Time, but they are definitely easier to create and modify.

To finish, I am just going to quote Robert Kosara and his blog on visualization Eager Eyes, "JavaScript for visualization is clearly the way to go. It's fast, versatile, works much better than Flash or Java, and is obviously way ahead of static images". You can check the complete post here.

Nounoublog updated

Sat, 06 Feb 2010 00:00:00 GMT

Over the last few weeks this blog has changed dramatically. It looks pretty much the same as when it started but under the covers the code of the blogging platform, Nounoublog is very different. I am going to talk about three of the features that I have been working on lately:

Archives
RSS Feed
Admin console

And I will show a few snippets of the actual code that powers the blog.

For those that visit the blog for the first time, Nououblog is a small blogging platform developed in Google App Engine. I started working on it basically for two reasons. First, I wanted to learn how to develop applications for Google App Engine. And second, because I wanted a simple but highly customizable platform, with free hosting and no ads.

RSS Feed

An RSS feed is a specially formatted XML file, which includes data about the posts in a blog. It is updated automatically by the blog, so that when it changes, RSS subscribers know that there is new content. There are applications like Google Reader that are very helpful to keep track of many RSS feeds and alerting when there is new stuff to read.

In the Nounoublog blogging platform, you can access the RSS feed by clicking in the RSS link at the top of the page. In the browser you may see only a bunch of text, but if you add this link to your Google Reader subscriptions you will see a list of the most recent posts.

Same as before the RSS feed is powered by its own handler, which is very simple:

class RssFeed(webapp.RequestHandler):
  """Handler for the RSS feed.

  This feed contains a list with all the blog posts, from last to first.
  This list is subject to the maximum item retrieval limit of the DB.
  """
  def get(self):
    # Get the list of all posts.
    posts = get_all_posts()

    # Return the xml feed with the posts.
    template_values = {'posts': posts}
    self.response.out.write(template.render(template_path("rss_feed"),
                                            template_values))

Where the template provides the XML structure of the feed, and inserts the data corresponding to the posts

<?xml version="1.0" encoding="iso-8859-1"?>
<rss version="2.0">
<channel>

<title>Javier Tordable Blog</title>
<link>http://www.javiertordable.com</link>
<description>
  Javier Tordable blog on Software, Mathematics and Technology
</description>
<generator>Nounoublog</generator>
<docs>https://code.google.com/p/nounoublog/</docs>

{# Loop over all the blog posts. #}
{% for post in posts %}
<item>
<title>{{ post.title }}</title>
<link>{{ post.absolute_url }}</link>
<pubDate>{{ post.rss_pub_date }}</pubDate>
<guid>{{ post.absolute_url }}</guid>
<description>{{ post.escaped_content }}</description>
</item>
{% endfor %}

</channel>
</rss>

Notice that in the Django template the post elements appear as attributes while in fact they are method calls. Also I use as GUID the url of the post, as it is intended to be a permanent link.

Admin console

The last item that I have been working on is the administration console. This is still work in progress, but I expect that once I am done with it I will post more often.

The admin console will have options to:

Add posts
Edit posts
Add static pages
Edit static pages
Edit the CSS
Edit redirects

All these options seem very normal with the exception of the redirects. How does it work? For example, when going to:

http://www.javiertordable.com/blog/2009-12-01/my-first-blog-post

You are redirected to another url, which appears in the url bar. Notice how the dashes are now forward slash bars

http://www.javiertordable.com/blog/2009/12/01/my-first-blog-post

I added support for redirects because I changed the site several times (including the url structure), and I didn't want to serve 404 error pages for all old urls.

Keep visiting the blog or subscribe to the RSS feed for more news on Nouonublog!

The Eternal Night

Sat, 30 Jan 2010 00:00:00 GMT

My brother David is a film director. He has been making short film for a few years, he has even won a few prizes. Most of his work is at tpmpictures.com. Today I just wanted to show his last piece of work, a science fiction short about the end of the world. The short is in Spanish but with English subtitles.

There are a couple of things that are interesting in this short. First, the script is not wildly improbable. Check out this (humorous) list of the 5 scientific experiments most likely to end the world. And second, the special effects are pretty nice for a zero budget short. If you liked it, please go ahead and leave a comment at the Notodo film festival.

TRANSCEND

Fri, 15 Jan 2010 00:00:00 GMT

A couple of days ago I started reading TRANSCEND, the new book from Ray Kurzweil and Terry Grossman. The book starts from the principle that our knowledge of medicine and biology is increasing to a point where we can start to control effectively how fast our own bodies age. And even more important the amount of knowledge that we gather is increasing over time. If the trend continues we may reach a point where we can effectively reverse engineer our bodies in order to avoid aging.

Whether you believe that we will reach that point or not, the book is an interesting read. It is filled with healthy habits, complete diets and recipes, exercise programs and more. Even if you leave aside the supplements and the fancy biomedical technologies, there are plenty of actionable tips for inproving your quality of life. For example to check for food intolerances. There are millions of people out there that can't digest milk or wheat very well and are not even aware of it.

Disclaimer: I didn't get paid to write this post.

MapReduce Integer Factorization in arXiv

Thu, 07 Jan 2010 00:00:00 GMT

This Monday I published my article on MapReduce for integer factorization in arXiv. The article is essentially the same that can be downloaded in the research section of this site. So if you have already checked it out, you won't find anything new. However I am very excited because it is my first addition to arXiv.

In case that you are not familiar with arXiv, it is one if the greatest scientific sites in the web. It has over half a million articles, especially in the fields of mathematics, physics and computer science, and many relevant papers are published in the arXiv months before they appear in any peer reviewed journal.

MapReduce Integer Factorization released!

Tue, 29 Dec 2009 00:00:00 GMT

Recently I published the code of MapReduce for Integer Factorization. It is available under the Apache 2.0 License in Google Code. It includes everything necessary to run in Apache Hadoop, as well as the numerical libraries used. It has no dependencies apart from the last version of Hadoop.

This project is a proof of concept that shows how to use MapReduce, a framework for distributed computation to solve a purely numerical problem. The main conclussion is that it's possible to use MapReduce for problems that lie far ahead from its original area of application, for example number theory. Also in this case the difficulty involved in developing the MapReduce program is similar to the difficulty of creating a worksheet in a mathematical tool like Maple. But the performance of MapReduce is significantly higher.

If you have some time, please download it from here, and let me know how it works for you.

A small blogging platform in Google App Engine

Thu, 17 Dec 2009 00:00:00 GMT

If you have never made a web application it may seem daunting. There are hundreds of alternative technologies and frameworks out there. And web apps development is quite different from client applications, which is what most developers are used to.

Here is an example of a web application. Wikipedia!

Most web applications share a few common elements:

A persistence layer, for authored content or user created content
A system to connect each user request with a part of the application
A method to render and display that content to users

Traditionally the persistence layer is a SQL database, the requests are directed for example to Java servlets in an app server like Tomcat, and there is a more or less refined templating engine, in which the content is added to create the whole page returned to the user.

Another alternative is Google App Engine. Google App Engine is a platform and a set of libraries to develop web applications based in Google's own infrastructure. It is available in Java and Python, but here I will concentrate on the Python version.

The persistence layer of Google App Engine is the Datastore, a highly parallel but simple to use storage solution. The Datastore doesn't support queries as complex SQL does, however it can scale up to a level which is beyond what a normal database can do. And it can do so in a way that is trivial for the developer.

Google App Engine uses yaml and the webapp framework to answer user queries. One can set a configuration file which assigns certain url paths (via a regular expression) to instances of webapp.RequestHandler.

handlers:
- url: /.*
  script: app.py

The instance can implement a get() method which generates the response returned to the user.

class App(webapp.RequestHandler):
    def get(self):
        self.response.headers['Content-Type'] = 'text/plain'
        self.response.out.write('Hello, World!')

Finally, in order to generate HTML, Google App Engine incorporates the templating engine from Django. A template is essentially a document with variables instead of content. When the application needs to answer a user request it can load the template and replace the variables with real content, for example information from the data storage.

This is basically the way that this blog is made. It is a very simple Google App Engine application. It uses the Datastore for the blog posts, which are retrieved when it receives a request for the /blog url path. Then it replaces the blog post content into the blog template and returns that content. Here is a sample of code. It is not the actual code, but it gives a complete example:

class Blog(webapp.RequestHandler):
  def get(self):
    # Retrieve the posts from the database.
    query = 'SELECT * FROM Post WHERE public = True ORDER BY date DESC '
         'LIMIT %d ' % NUM_POSTS_IN_MAIN_PAGE
    posts = db.GqlQuery(query).fetch(NUM_POSTS_IN_MAIN_PAGE)

    # Render them into html.
    if len(posts) > 0:
      template_values = {'posts': posts }
      template_path = os.path.join(os.path.dirname(__file__), 'templates/blog')
      content = template.render(template_path, template_values)
    else:
      content = ''

    # And return a full page with the blog content.
    s = pages.FullPageGenerator()
    self.response.out.write(s.generate(content))

To sum up, Google App Engine is a great option for developing web applications. Expecially if you will require it to scale seamlessly, or to integrate with Google services. Check out the Google App Engine tutorial.

Interesting Visualizations: Changes Over Time

Thu, 03 Dec 2009 00:00:00 GMT

Visualizations are simply ways of representing data. But if they are good, they can bring us deep insights, that go well beyond what is possible to understand by simply looking at the raw data.

There are several categories of visualizations, for example:

Compare two entities based on a given set of metrics. An example of this is a benchmark between two competing companies or products
Track the value of a given metric over time. A well known visualization of this type is a financial chart, with the value of an asset
Compare the value of a single metric in different geographic locations. We have all seen maps in which the color of each region is based on the value of the metric

Another very interesting set of visualizations are those that allow us to track a particular situation over time. Here are three examples:

Tracking a change in ranking over time (by Ciaran Hughes)

Tracking a change in distribution over time (from GE). The bottom slider changes the chart based on the age. Each section of the chart represent one kind of illness

Tracking changes in volume or magnitude over time (from xach.com). Each color block is a movie, and the size represents the box office in each week.

The first visualization doesn't attempt to indicate quantity because it displays an abstract concept such as brand appreciation. However in the third case the quantity is very concrete, the total box office in dollars.

We could use also the first or third approach for the second data set. But if we went with the first kind of visualization most likely we would only remember the most important expense for each age. Also we would be constrained in the number of years to show. If we decided to go with a visualization of the third kind it would be hard to compare how the expenses change relatively to each other as all of them are likely to increase over time.

My first blog post

Tue, 01 Dec 2009 00:00:00 GMT

Hello everybody. This is the first post in my new blog. This is not your common Wordpress or Blogger blog. It runs on a custom blogging platform made from scratch, on top of Google App Engine. Soon I will add a couple of posts about how it's done, and I will release the code of the platform.

In the future I will use this blog to talk about stuff that interests me. For example:

Google App Engine, Django and other tools for rapid web application development
Sage, an open source mathematics package
Devi Prasad Shetty, and how he transformed medicine through mass production
Interesting visualizations! As information is more and more available it is becoming increasingly important how to visualize and understand easily

The subscribe links don't work yet, so I am afraid you won't be able to read this blog in your favorite RSS reader. But I hope that I will see you again soon. Thanks for coming!