Random Musings from Jay Myers

Rollin’ with schema.org vanilla reviews markup

Jay — Thu, 13 Oct 2011 17:02:34 +0000

Vanilla Ice was also rollin' -- in the 80's

Well folks, it’s deployment season again here at Best Buy, which means lots of changes, late night code deployments, and business project managers running around with their hair on fire. It also means it’s time to sneak some good structured data type stuff on to the site without actually having to explain in detail what’s so gosh darn important about delivering rich data in our site’s HTML output. It’s with great pleasure that I announce the official launch of schema.org reviews markup on all pages of bestbuy.com, gradually rollin’ out over the next couple of days to a browser near you.

So why schema.org? I was fortunate enough to participate in the schema.org workshop in Mountain View last month where a bunch of really smart people were talking structured data on the web. If you know anything about the history between some of the individuals attending, you’d figure we would have several opposing viewpoints and many arguments would ensue. To my surprise, this was not the case — we had a great day of very constructive talks. And with this warm and fuzzy spirit of goodwill, I figured it was time to put the rubber to the road and release a new standard for all to test.

If you’re still wondering why schema.org, please take a gander at these thoughts:

Yep, it’s Microdata, but it’s about schema, not syntax. I’ve been doing my homework, and I believe the product reviews vocabulary created by the Google-Rich-Snippets-now-schema.org group is a solid and well thought out vocabulary. Additionally, the consensus from the workshop was the support of multiple syntaxes, so I’m not terribly worries about being lambasted for trying a new syntax .
I still love RDFa. One of the greatest things about RDFa is it’s out of the box support for multiple types/ vocabularies, which was also a desired requirement coming out of the schema.org workshop. I was also moved by the excellent presentation by Ben Adida, where he talked RDFa and the new RDFa 1.1 Lite, which looks very, very promising. Plans are already in the works to port a segment of the reviews to RDFa 1.1 Lite, with a little help from my friends.
Continuing to push for changes in the schema — most notably support for multiple types.
It could be one of the first large deployments of schema.org serve as an example. Suggestions? Comments? Want to see the code change to point your parser at? Let me know, let’s create something wonderful for the web.

Finally, if you’re curious, check out this Sony TV example.

Justin Bieber Loves the Semantic Web

Jay — Thu, 28 Apr 2011 18:35:42 +0000

The magic continues as we try to move the technology dial forward on bestbuy.com. Along with some other fun forward-thinking stuff, we also encoded all our music product detail pages with RDFa, featuring such great vocabularies as GoodRelations, the Music Ontology, Dublin Core, Facebook OpenGraph markup, and Google’s (Rich Snippets) Breadcrumbs RDFa spec to provide a complete front-end semantic solution to assist machines in reaching valuable product data directly through the browser.

Now I know many of you aren’t the CD buyin’ kind (what the heck is a CD?!), but the following Justin Bieber example can serve as an example for physical media as well as digital scenarios.

Feast your eyes on the human version of Justin Bieber in all his teenage glory as he funks it up with the greatest artists of our time like Ludacris, Usher, and Jessica Jarrell (http://www.bestbuy.com/site/My+World+2.0+-+CD/9771571.p?id=2086661&skuId=9771571):

Justin Bieber on bestbuy.com (click for full image)

Running it through an RDFa distiller produces some interesting data results. First the GoodRelations offering:

gr:Offering of Justin Bieber (click for full image)

Breaking the offer down, we see this offer has two price specifications. The first specifies the current price. The second highlights the standard retail price (list). Hey, it looks like this masterpiece is on sale!

Justin Bieber hasPriceSpecification! (click for full image)

The second part of the gr:Offer focuses on the product details including UPC (EAN), SKU, product image, and product type, etc.

Justin Bieber's album details (click for full image)

So let’s talk deeper product details data next. Music releases have evolved from focusing on the entire album to diving into track details. Of course, any serious Bieber fan will want to consume every last second of every track, but the less infatuated fans purchase individual tracks instead. The Music Ontology provides a perfect foundation to list and highlight track details:

Justin Bieber track listing in data (click for full image)

There’s no question that Bieber fans will be praising his work and want to share on Facebook. Since OpenGraph has become the rage in the semantic world (second only to Bieber himself), we’ve added og: meta information in the head of our HTML:

Justin Bieber hits the opengraph (click for full image)

If you run J.B. through the official Facebook URL Linter product details are extracted:

Running Justing Bieber through the Facebook URL Linter (click for full image)

This product page is an object on the OpenGraph!

I encourage you to run your parsers against any one of our music product detail pages and share the results. Work is ongoing to provide an XML sitemap just for music products — stay tuned for more information. In the meantime, I’m waiting for internet sensation Rebecca Black to muster up some more hits to throw on a full album so we can mark it up in RDFa.

* Disclaimer: the opinions of Justin Bieber and related artists is that of the author and not that of Best Buy, Co., Inc., it’s subsidiaries or employees.

Released! Human Product Discovery Via Machines, RDFa and “Shop URLs”

Jay — Tue, 26 Apr 2011 12:54:21 +0000

Well folks, we’re at it again. The month by month the journey continued Monday into Tuesday night to semantify the hallowed templates of bestbuy.com. One of April’s goals: to enhance machine understanding of Best Buy’s considerable product offerings while retaining human searchability and readability. After long wait, we have deployed code to the search templates to establish a human-readable and machine-parseable front-end API.

Many moons ago (even before all this RDFa goodness), we established a URI scheme we call “shop URLs”. Basically it’s an easy way to pass a search term in a URI and get a visual list of up 50 products our search appliance considers relevant. However, when you have a catalog of 400K+ products, simple visual results may not be the best or most efficient way to sort through the cruft and get at what you’re looking for. Enter stage left our friendly machine helpers: Search Engines, Parsers and Aggregators — this deployment activity is focused on feeding you! We’ve deployed step one of enabling a solution to product visibility and discovery issue by unleashing the result data in RDFa (with GoodRelations, Dublin Core, FOAF, Google Ratings vocabs) for maximum machine parseability.

After all this grandeur and hype, I’m hoping you’re still interested in how it works. You may point your eyes and parsers here:

http://www.bestbuy.com/shop/search+term*

* Please note, due to marketing and business considerations, some of the more popular terms may redirect you to a dataless “category page”. To get a RDFa-enabled result, simply append a * to your search term, e.g., http://www.bestbuy.com/shop/ipods* (how dare those marketing people stand in the way of good data!)

Let’s dive deeper with a quick example. So I’m a bit eclectic and looking for a thermometer online. I would like to see results of the “thermometers” from bestbuy.com, plus pass the data to my machine friend, an application I am building to help me make the right product choice.

First I type access my human-friendly representation using a “shop URL” directly in the browser:

http://www.bestbuy.com/shop/thermometers

Which results in a human-readable web page:

human-readable shop url

Looks like I have 15 product offers that match and are available via bestbuy.com or in store. Excellent.

I’m going to take that same URI and pass it on to my machine helper who just wants the data, no fluff. Let’s say we’re working with RDF/XML…on the surface, the 15 product offers may appear like this:

rdf extract from shop url

Expanding an individual offer yields the following data-rich result:

expanded data extract of shop url

So endeth the second phase of sematification. Make sure and leave your API keys at home, this search data is all open! Tune in for more later this week, I will be discussing another one of April’s goals, expanding RDFa markup to Best Buy’s product detail pages.

Smarter Check Availability Page on Bestbuy.com with RDFa

Jay — Tue, 15 Mar 2011 19:52:37 +0000

Recently we’ve set off on a project journey something we’ve thoughtfully nicknamed “browse widening”. The basic aim of the browse widening project is, well, to make the site wider (groundbreaking, I know). Because this activity (in theory) should take a dev about 5 minutes to accomplish, we have decided to stick a couple of extra nuggets into the “requirements” of the project. As part of my ongoing passion to turn bestbuy.com into the most data-rich website on the planet, I am augmenting the site’s HTML with RDFa and vocabularies like GoodRelations, vCard, and Google’s review vocab, integrating rich product and store data directly into the front-end user experience to maximize the machine extractability and readability while preserving the visual user experience as it stands today.

In late February, we deployed the first iteration of RDFa-enhanced browse widening to the Check Availability page. In it’s current state, users who navigate through the bestbuy.com browse experience and check availability on products are taken to the check product availability page. If unrecognized or unauthenticated, the user is required to enter a zip code which shows the availability of said product at the closet store locations. If authenticated, the user is taken to the product availability page with their preferred stores availability status.

On the surface, this seems like your run-of-the-mill product availability page. But if you peel back a layer and view source on the HTML code, you’ll find a literal treasure trove of rich product and store data. Let’s take a peek at an example of a product that has varying store availability to show the data we’re making available to machines, and, most importantly, the RELATIONSHIPS we’re establishing between the product and where it “lives”.

First we’ll start with a code snippet highlighting the offering and product details:



	
	
	
	
	
		
			
			
			
				
					
						Apple® - iPod shuffle® 2GB* MP3 Player (4th Generation - Latest Model) - Orange
						

						Model: MC752LL/A | SKU:9845572

To the average HTML layperson, this markup might not equate to much. But let me assure you, there is some very interesting and powerful data modeling at work here, delivered directly through the HTML markup. Let’s take a granular look at what is going on in the code by highlighting individual parts of this snippet. To start, we declare the namespaces of the vocabularies we’re using in our solution. For the Check Product Availability page we combine GoodRelations, FOAF and vCard vocabularies to model the complete solution.

Next, we identify a unique identifier for each product offer, using the gr:Offering class. My naming convention includes the UPC of the product with a zero prepended to it, which essentially is the standard format for EAN — a world-wide identifier used everywhere except the US (take that world — you, your EANs and crazy metric system can take a hike!). I’m a big fan of the UPC as product identifier — of course the “u” stands for “universal” which I dream could serve as a sort of “primary key” for product searching on the web.

The next section of code is where we start to see relationships forming. For this example, we see four span tags with gr:availableAtOrFrom and unique hash identifiers. The importance of this code as a relationship builder (the “cupid” of the GoodRelations solution?) will become more apparent later in the example. For now, let’s just recognize that it’s key to informing machines where the product offer can be procured, ie, where the product is in stock.

Our next sub-snippet encapsulates the product offered in the offering (via gr:includesObject), product type and quantity (via gr:TypeAndQuantityNode) and the description and attributes of the product (via gr:typeOfGood and it’s child methods). As you can see, we utilize GoodRelations as the “base” vocabulary, but also include FOAF and RDFS vocabs to provide a full solution. This is also where we dive deeper into product details, far beyond surface level attributes like price. foaf:depiction for a product image, gr:hasMPN for manufacturer product number, gr:hasStockKeepingUnit for SKU, and gr:hasEAN_UCC-13 for EAN (UPC) give machines access to important product attributes that are beneficial to allow machines to make sense of the massive amount of unstructured product data out on the web today.


	
		
		
		
			
				
					
					
						Apple® - iPod shuffle® 2GB* MP3 Player (4th Generation - Latest Model) - Orange
					
					

					
						Model: MC752LL/A | SKU:9845572

Finally, we produce the list of stores with their location data and product availability status. Luckily for machines, we are coding these results using vCard RDFa — providing a rich consumable result (truncated to two store results for readability):


	
		RICHFIELD MN
		
			1000 WEST 78TH ST,
			RICHFIELD,
			MN
			55423
		
		
			Map & Directions
		
	
	
		
			Available now
		
		

		Pick up 03/15/2011
	
	 
		
	


	
		EDINA MN
		
			3200 SOUTHDALE CIR,
			EDINA,
			MN
			55435
		
		
			Map & Directions
		
	
	
		
			
				Ship to store
			
		
		Usually ships to store in 3 to 5 days

Now that we have rich markup for our offering, the product and the store locations, it’s time to examine the magic that is inherent in this solution. Remember gr:availableAtOrFrom? It’s part of the key to establish RELATIONSHIPS, which is part of the sweet, sweet goodness of Semantic Web and Linked Data. In our HTML result, stores that have the product on hand are represented by a gr:availableAtOrFrom node which contains a resource attribute. This provides an inter-document pointer to the rich store location details (marked by the “about” attribute), essentially linking a product offer object to a store object and it’s location attributes. Stores where the product is not physically available do not return a gr:availableAtOrFrom. From this RDFa model, a machine can assert product availability – and extract rich location details about the stores where the product is in stock. A truncated code example may help here:





[code]...



RICHFIELD MN

[etc]...

Planning Phase 2 -- Matrix URIs

The examples you see here represent the first phase in a two-phased approach to deliver the smartest Check Product Availability page on the web today (at least for the next couple of months until everyone else catches on). As I mentioned in the intro, the code featured here is available through the human browse experience, so physical clicks of the mouse are necessary to resolve to the RDFa-enriched data endpoints. For phase 2, I would like to introduce a direct RDFa endpoint via Matrix URIs to complete the machine-readable portion of the solution.

If you're unfamiliar with the concepts and structure of a Matrix URI, there is an interesting write-up from Tim Berners-Lee back in 1996 that outlines the design. Imagine this Matrix URI being the canonical URI to access very rich data about a product and it's availability:

Using these methods enables the unleashing of important data on the web that provides machines with a greater visibility and understanding of the products, goods and services we offer -- all without an API key. We're not stopping at Product Availability -- keep you're eyes open for our next iteration where we will enable the smartest search results pages using RDFa and friendly "shop" URLs. Don't miss it!

A Strategic Formula for Business Data and Semantics

Jay — Thu, 09 Dec 2010 18:18:39 +0000

I’ve had the good fortune of sharing the possibilities, power, and my personal vision of the semantic web with a number of audiences in the past couple of months. This has also given me a great deal of time to think deeper about how we can utilize the massive amount of unstructured data that exists now on the web. There’s a lot of beneficial data out there, information companies can ingest and use in machine learning, and data that should be openly shared externally and made available for both humans and machines to access and distill.

While brainstorming new ideas for my next go at an interesting presentation, I concocted a very simple “strategic formula” that I believe all business and organizations could leverage when it comes to the Semantic Web, Linked Open Data and, well, just data in general. It looks a little something like this:

So what do these spheres mean? Anyone who sells something or provides a service that people use should be looking for as much exposure as they can get on the web. The external data sphere represents human and machine readable data that you’d want everyone to access. One of the primary vehicles gaining popularity on the web is RDFa, a way of utilizing richly annotated HTML to deliver data to machines while retaining the rich visual web human users have become accustomed to. There are also markup techniques like Microdata that do a similar job, allowing us to enrich HTML utilizing semantic vocabularies like GoodRelations to create virtual representations of real world physical objects. Search engines like Yahoo! have been taking advantage of rich data markup techniques for years, and Google has built RDFa, Microdata and Microformats support into their Rich Snippets initiative. The great thing about “front-end” semantic markup techniques is with a little additional knowledge and tools, it allows countless numbers of HTML devs to create a very rich web of data by simply adding data annotations to their HTML, essentially making the entire web an open and queryable database or API for us to extract knowledge from.

On the other side of the spectrum, most businesses have proprietary or sensitive data that they would not want to expose, but could still utilize internally for business benefits. This is where non human-readable semantic data technologies like RDF/XML would be useful. Companies could build internal apps that query a large amount of data that they posses, but typically don’t utilize. What if I could mash up internal data like product margins, inventory levels, along with store trend data and the “sentiment of the web” and start asking it questions? I can see benefits that touch every aspect of the business, from extremely contextual consumer and associate-facing product recommendation engines to merchandising tools that automatically determine trends and adjust product levels across the enterprise, even down to the region or individual store level, with limited human involvement.

Combining these external and internal data structures will result in insights — a necessary resource needed by all companies simply to survive in the current extremely competitive landscape. Data-driven insights are device, platform and trend agnostic, meaning they can easily be utilized and deployed to any new app, operating system or device. With the online space rapidly transforming into a “splinternet” of device types and methods for consuming and producing data, a solid base of semantically structured and linked data will be key to the next generation of successful enterprises.

Creating Machine-explorable Product Categories Using RDFa and SKOS

Jay — Wed, 09 Jun 2010 16:13:05 +0000

If haven’t guessed it already, I’m a big fan of the GoodRelations vocabulary as a solid way to describe products, product offers and shop locations. However, most SemWeb vocabularies have some sort of logical limit — for scalability and pure practicality, most don’t include every single data attribute that could possibly describe the object they are annotating. To create complete semantic solutions, you usually start to combine various ontologies.

As complete as GoodRelations is, I have been searching for a way to annotate product types/ categories with it. Product categories can be unique to retailer/ manufacturer, and with billions of consumer products and endless numbers of product categories, universal product categorization seems to be an unreachable goal. I have seen a few attempts at mass product categorization, but I haven’t seen a ton of progress (who would want to manage a massive global product taxonomy?!). Furthermore, getting consensus on category definitions seems like a futile effort that should really be avoided.

However, just because there aren’t any universal standards out there doesn’t mean we can’t start giving machines a shot at some semblance of product categorization. We can begin to provide definitions to product categories by annotating our HTML with RDFa and SKOS (along with other vocabs like GoodRelations).

There are a couple of initial use cases I have identified:

Parsing navigation to capture general product hierarchies

As retailers, we should want to let the world know what kind of products we sell. In my day to day duties, I’m always surprised at what type of products I uncover on our site (especially during project QA!). With around 650,000 active SKUs on any given day, there is much to explore. Of course this is a nearly impossible task for a human to do, so it makes sense to expose these rich data points in our HTML using RDFa and let the parsers do the work for us. This data is not only useful for external consumption, but internal as well. Throughout the ecommerce world there is also significant human effort dedicated to updating and maintaining product taxonomies — many organizations have entire teams dedicated to this activity. What if we could rely on smart machines to perform this function and make “recommendations”? My experience tells me there would be a whole lot less bickering in the workplace.

Enough of the justification, here’s an example and code snippet to ponder:

Faceted commerce navigation example


	Shop TV & Video
	
		TVs
		Projectors & Screens
		Blu-ray & DVD Players
		Home Theater Systems
		TiVo & Internet TV
		Digital TV Converters
		DIRECTV, Cable & Fiber Optics TV
		Stands, Mounts & Furniture
		Portable TV & Video
		TV & Home Theater Services
		TV & Video Accessories

Assigning product categories through product detail page “breadcrumbs” with SKOS and GoodRelations

As I mentioned previously, I have been searching for a good way to annotate product categories/ types with GoodRelations. A common practice on commerce sites is the utilization of breadcrumbs — as a visual reminder of where you are in the shopping experience. We can annotate these breadcrumbs with SKOS in the domain of GoodRelations (child of gr:includesObject) to completely categorize a product, building a product category hierarchy from top-level category down to more narrow child categories.

Example and code:

Best Buy local store open box detail page with breadcrumbs


	
		
			Best Buy
			TV & Video
			TVs
			All Flat-Panel TVs
			Product Info

Full HTMLs for your perusal: facted-nav-skos.html, gr-skos-breadcrumb.html

Creating Local Visibility to Open Box Products with Front-End Semantic Web

Jay — Tue, 30 Mar 2010 19:38:24 +0000

Let’s face the facts, it’s a tough job to be a retailer these days. Competition is fierce, customers are demanding, and product margins are razor thin. Just when retailers finally get that product into a customers hand and out the door, it can come marching right back into the store as a return. In fact, studies estimate there are tens of billions of dollars worth of product returned back to retailers, and very small percentage of those are actually defective. This means that brick and mortar retailers have plenty of fully functional open box products gathering dust on shelves and are missing an opportunity to get these units back into the hands of customers.

All of our local Best Buy stores are challenged with returned products. Our physical stores can be silos of beneficial product data, especially when it comes to the availability and reduced price scenarios presented by open box products. Up to this point, our open box items have not been openly displayed on the web — we tend to focus on new, unopened products, leaving an huge unmet opportunity at the store level to increase web visibility to returned products.

While this seems like a large problem to tackle, we have found a forward-thinking way to increase the visibility of open box items at our local stores using the power of open source software and open front-end semantic data standards without employing traditional marketing tactics to push individuals toward these products. Earlier this month, we began rolling out the capability for store associates to contribute to the web of data while increasing visibility to their local open box products through a simple WordPress plugin and RDFa templating mechanism. Each Best Buy store is empowered via their local store WordPress blog (background here) to enter the SKUs of the open box products they have in their inventory. The plugin fetches the relevant product data using Best Buy’s Remix API and the user is prompted to enter the open box price and a reason the product was returned. With one last click, the user saves the data and the product is published to the store site, is made available to the semantic web through front-end RDFa templates and auto-generated XML sitemaps.

There are some interesting features, techniques and potential outcomes of this work that are worth discussing:

Utilizing GoodRelations product vocabulary with RDFa. If you are currently looking for a semantic way to expose your products, store locations, store hours, etc., GoodRelations is fast becoming the ontology of choice. Combining this with RDFa markup (or microdata?) creates rich data and visual experiences over the web, enabling webmasters to contribute to the web of data via their rich HTML, and parsers/ machines to glean data directly from a customer facing web site. Could RDFa or microdata become an authoritative source for visual consumption by humans AND data consumption by machines for things like consumer goods and services?

Cool/ clean permanent URIs. It’s a fairly common SEO practice to create descriptive URIs with things like object names, categories, or special character escaped product titles in them. We have mimicked this practice in our URIs, recognizing that this entity is a product, its condition is “open box”, and highlighting the product title:

http://stores.bestbuy.com/577/fairless-hills-pa/products/open-box/frigidaire-30-freestanding-range/0012505540066/?uid=118

Our technique for open box products also takes it a bit further, as these products are unique to a single Best Buy store and have a specific open box price that may differ from other units with the same SKU or UPC. One desire of this project was narrowing the scope of these unique items to the local level, as they are only available for purchase in store. One way we have attempted to solve for this is putting the store number, plain text location, and a unique product identifier in the URI:

http://stores.bestbuy.com/577/fairless-hills-pa/products/open-box/frigidaire-30-freestanding-range/0012505540066/?uid=118

Lastly, we’ve decided to break away from proprietary Best Buy catalog conventions and highlight the thirteen digit product EAN (UPC with an additional 0 prepended). Many retailers including Best Buy utilize proprietary catalog or product ids for their commerce platforms, which forces search engines, product comparison engines, and the like to build separate functionality to match the specific retailer’s products, or do additional digging to complete product matching and return relevant results. It would seem the sensible thing to do for retailers (and manufacturers too!) to utilize and expose the UPC/ EAN spec as a sort of “primary key” for products across the web. I’m attempting to lay the groundwork starting with exposure in the URI:

http://stores.bestbuy.com/577/fairless-hills-pa/products/open-box/frigidaire-30-freestanding-range/0012505540066/?uid=118

Creating relationships between the product and where it “lives”. Using the inherent features of linked data and semantic web, we are easily able to establish links between product and store. This is another technique utilized in this project to narrow focus down to a local level. Essentially we are using semantics to say, “I’m a specific product entity available at this permanent URI, where you can discover more about my n attributes. You can locate me at this specific store entity via its URI, where it exposes rich location and hours of operation data to make it easy for you to acquire me.”

Makes semantic web publishing accessible to everyday employees. I believe the semantic web movement still struggles with the chicken/ egg scenario — data publishers may not be creating semantic data because of a perceived lack of applications to parse their data, while application developers may not be actively creating new software to consume and use semantic data. With this simple toolset we have unleashed the power of our workforce to publish extensive local product data sets to the web using open standards, making them accessible to new applications for consumption and parsing.

Low cost of entry, low level of difficulty, potentially high return on investment. While larger enterprises may want to integrate semantics into their enterprise systems, there are ways to start contributing now to the web of data without having to adopt a specific technology platform by simply coding it into your templating engine. Kudos to Drupal, osCommerce Shop Software, Joomla/Virtuemart CMS/Shop combo, and others for including semantics natively or making them available via modules or plugins.

I invite you to see more, test, parse, and make comments or constructive criticism by visiting some of our more active stores. Follow these links to aggregate listing pages and click through to analyze individual product markup:

Unexplored SEO Opportunities Utilizing Semantic/ Structured Web

Jay — Tue, 29 Dec 2009 20:26:11 +0000

There has been a flurry of chatter around the potential impact of RDFa on SEO after my brief presentation at SES Chicago 2009. In subsequent conversations with SEOs at the SES conference and folks from around the industry, I was surprised at how many people practicing SEO weren’t involving their web developers in their solutions, but rather focusing mostly on content, linking and social strategies. While these solutions are key in any SEO activities, the fact that our panel discussion and presentation was the only one involving code and coding techniques surprised me. This raises an interesting question: are many SEOs missing a core element to success, namely well structured, semantically-rich core web sites?

One can look at the current state of HTML on many web sites as an indicator of where people are focusing their efforts. The research performed to create the hProduct Microformat draft spec gives some good insight as to the condition of front-end HTML code. For years we have been building web sites mostly for visual, presentational (human-readable) purposes, and this is clear in many pages of source code analyzed for the hProduct spec. Luckily, search engines have done an incredible job of parsing out the junk and extracting the contextual and important data from billions of web pages. Machines have become vital to helping us learn, but up to this point there has been an imbalance in human-readable vs. machine-readable front-end code. Now there are emerging techniques and technologies that web developers can easily use to correct this by coding their pages to give them meaning to humans AND machines.

By combining rich front-end user and data experiences utilizing RDFa, Microformats, or the emerging Microdata spec, we build direct pathways to rich datasets, which enable machines (mostly search engines, but also next-gen parsers, browser plugins, etc.) to easily access important data and apply their algorithms, etc., to make sense of it all and index it in the ways they see fit. My personal theory is that by providing more direct access to data through front-end semantic code, machines will spend fewer CPU cycles parsing presentational code. These extra resources could then be re-allocated to better natural language processing, extending search into the “deep web”, or other efforts to make the web and it’s users smarter.

Of course this has implications to the SEO/SEM world. It forces SEO professionals to engage their web developers or become slightly more code savvy themselves. It shifts more emphasis on developing strong, data-driven semantic web sites that balance the visual needs of humans and the data needs of machines, rather than focusing on seemingly artificial techniques that increase “link juice” or utilize “secret sauce”. Using traditional SEO content strategies in combination with building strong data-rich web sites can lead to a more intelligent and useful web, which is ultimately good for businesses, users and consumers.

Example Best Buy Product RDFa Markup Released (beta)

Jay — Mon, 26 Oct 2009 15:54:35 +0000

There is a good amount of chatter about the semantic web out there, but not a ton of concrete, working examples. I decided to put our Best Buy data to work and publish BBY SKUs in RDFa, using the GoodRelations e-commerce ontology. As I see it, simply publishing the RDFa is not an issue — the challenge is to apply real-world style and structure to the code to make it both machine and human readable. I’m trying to answer the question: is the RDFa model flexible enough to allow Joe Web Developer to successfully publish valid structured data while satisfying the desires of his design, business, and marketing counterparts?

I’m pleased with the first round of results, ~460K worth of “next-gen” product detail pages. Take a look at some choice example SKUs from the Best Buy product catalog:

Music SKU: http://products.semweb.bestbuy.com/y/products/9312861/
Movies SKU: http://products.semweb.bestbuy.com/y/products/7590289/
Software SKU: http://products.semweb.bestbuy.com/y/products/9509686
Games SKU: http://products.semweb.bestbuy.com/y/products/9346442/
“Hardgoods” SKU: http://products.semweb.bestbuy.com/y/products/8967228/

Interested parties can get a full URL list here (txt, gz), or split up into list 1, list 2, and list 3 (txt).

Thanks to: Martin Hepp, Andreas Radinger, Alex Stolz, Yahoo! Searchmonkey, Jason Galep (design guidance), and Best Buy Remix.

Zompire Dracularius

Jay — Tue, 20 Oct 2009 15:44:01 +0000

I saw an interesting post today via Twitter from a local person hosting an SEO competition to see who gets the highest Google search result for the key words zompire dracularius. I am officially throwing my hat in the ring. Recently I have been investigating how good semantic markup (including RDFa/Microformats) in the front-end will improve or change the way search engines work — basically how POSH (plain old semantic html) delivers data directly to the browser with particular markup. For the purposes of this test I have employed some semantic markup techniques, plus a few other tactics to raise the visibility of my post:

Using RDFa in my posts (dublin core)
Creating a “human readable” URL for this post using permalink structure built into WordPress
Providing links to the original post and other sources (I will attempt to trackback, although no trackback link is published)
Send to social networking sites I participate in — this is done automatically when I publish a post on my blog to Friendfeed, Twitter and Facebook
Attempt to leverage my blog’s overall visibility to force my post about zompire dracularius to the top
Leave a comment on the original blog declaring the contest
Have an adequate number of references to “zompire dracularius”

While it seems a little “Black Hat SEO”/ dirty to me, I will ignore that feeling for a while for the purposes of the experiment. Results to come!