The summer of transparency
Let’s take a look at one example of Google’s innovative power and scope. The example shows how transparency can make it easy to overlook some of the inner workings of Google’s software.
The Google App Engine Guy, whose url is appengineguy.com, reported on June 12, 2008, "Google App Engine does have support for full-text search. It’s just not documented, because the feature is still in development."
He continues: "The DataStore is built on top of Google’s BigTable, which is a huge ... database that powers a lot of projects at Google, including Search Indexing ... The Google App Engine API has a very primitive implementation of a full-text index for the datastore, hidden away in google.appengine.ext.search. (There is basically no documentation of it, so you have to read the source ... ) You use it by creating your models from search.SearchableModel, instead of the usual db.Model."
Mr. App Engine Guy provides a Python code sample showing how to use that undocumented feature in the Google App Engine. Remember, instructions in Google code are put there by Google engineers.
1. from google.appengine.ext import db
2. from google.appengine.ext import search
3. class Article(search.Searchable Model):
4. title = db.TextProperty()
5. publishDate = db.DateTimeProperty(auto_now_add=True)
6. text = db.TextProperty()
7. # should NOT be returned
8. article = Article(text =’’’’’This is the totally secret article text
9. which talks about sausages and cheese in the middle of itself.’’’)
10. article.title = "Fine cuisine"
12. # should BE returned
13. article = Article()
14. article.title = "What I feed my dogs"
15. article.text = ‘’’’’This is the totally secret article text
16. which talks about sausages and cheese in the middle of itself.’’’
18. print "Results"
19. query = Article.all().search
("sausages cheese dogs").order("-publishDate")
20. for a in query:
21. print "%s | %s" % (a.title, a.publishDate)
22. print "Done printing"
Let me offer a few comments about this chunk of python. In Lines 3 to 6, Mr. Guy defines a new class, Article, as a subclass of search.SearchableModel. When instantiated, an Article object will represent a database table, with a timestamp indicating when the entry was created, and two text fields for a entry title and its corresponding text. Lines 8 to 11 have him putting an entry into the datastore; he puts in another in Lines 13 to 17.
Now that the datastore has some sample data, he can run a keyword search as shown in Line 19, with the rest of the code devoted to printing the results, which in this case will only be the second entry, as it is the only one containing all three search terms in either the article title or text.
Granted the function is limited, but this is an example of Google’s approach to its business. There is more there than meets the eye.
The App Engine was greeted with hoopla and considerable enthusiasm. Developers poked the code, and a flurry of applications became available. You can find some of them at http://appgallery.appspot.com. There are many useful links that you can explore.
On the surface, Google is becoming more communicative. I am not sure I would use the word transparency to describe the messaging. However, as Mr. App Engine Guy revealed, Google has tiny stublets buried in its code. Maybe these stublets are vestigial just like my appendix? On the other hand, maybe these are placeholders for additional functions that will be dropped in at some point in the future.
My take on this is that Google is a company that requires close study. The public statements capture headlines, but the inner workings of Google continue to be shrouded in the joy of insider secrets that math club members enjoyed at my high school.
Every time I read an article about Google with comments about fun, helping users and solving global problems, I marvel at what is underneath the shiny surface.