Extracting structured data from weblogs

Abstract

Methods and apparatus for extracting structured data from weblogs are disclosed. In some examples, the methods and apparatus include a web crawler to access a home page of a weblog, and identify a feed associated with the weblog. The methods and apparatus also include a feed finder to determine whether items in the feed contain sufficient content for feed-guided segmentation. The methods and apparatus also include a feed classifier to determine whether the items in the feed contain full content of the weblog. The methods and apparatus also include a wrapper to map data found in the feed into a representation of a weblog post, and screen scrape the weblog into the representation of the weblog post.

Description

CROSS-REFERENCE TO RELATED APPLICATIONS

This application arises from a continuation of U.S. patent application Ser. No. 14/881,071, which was filed on Oct. 12, 2015, which is a continuation of U.S. patent application Ser. No. 11/454,301, which was filed on Jun. 16, 2006, which claims the priority of U.S. Provisional Patent Application Ser. No. 60/691,200, which was filed Jun. 16, 2005. U.S. patent application Ser. No. 14/881,071, U.S. patent application Ser. No. 11/454,301 and U.S. Provisional Patent Application Ser. No. 60/691,200 are incorporated by reference in their entireties.

BACKGROUND

Weblogging or “blogging” has emerged in the past few years as a new grassroots publishing medium. Like electronic mail and the web itself, weblogging has taken off and by some estimates the number of weblogs is doubling every 6 months. As of June 2006, BlogPulse estimates place the number of active weblogs at nearly 10 million blogs, of which about 36% have had at least one post in the past 3 months. BlogPulse finds approximately 60,000 new weblogs each day. Statistics published by other blog search engines such as Technorati and PubSub are similar. However, these estimates may well be excluding large numbers of non-English language weblogs.

A weblog is commonly defined as a web page with a set of dated entries, in reverse chronological order, maintained by its writer via a weblog publishing software tool. We can define each entry as a set of one or more time-stamped posts; an author may typically post several times a day. This is a matter a style, as some authors post at most once a day in an all-inclusive entry. Others prefer to micro-post, making each published item a separate post in the day's entry.

Due to the popularity of weblogs, there is a need for a method of searching individual posts within weblogs. The present invention addresses this need.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a sample page from a weblog.

DETAILED DESCRIPTION

1. Overview

The present invention provides a process for segmenting weblogs into posts. Weblogs can facilitate communication and dissemination of content in any environment having two or more workstations in mutual communication. While weblogs are typically hosted by a server connected to the Internet, the concept can include other types of networks, such as local area networks (LANs), wide area networks (WANs), and public data networks, by which client workstations obtain data from a server workstation.

Each workstation may comprise a microcomputer such as a personal computer, for example, including a system bus that is connected to a central processing unit (CPU) and to memory, including read only memory (ROM) and random access memory (RAM). The system bus can be connected, via appropriate interface known to persons skilled in the art, to various input/output devices, including additional nonvolatile data storage devices, video and audio adapters, keyboard, mouse, and other devices that provide input to the workstation or receive output from the workstation. The Workstation can also include a data port for communicating with other constituents of collaborative data processing environment. The data port may be a serial port for linking workstation to a modem or a communications adapter for connecting workstation to a LAN.

Each workstation also typically includes software programs that are stored on the data storage devices or retrieved from other parts of collaborative data processing system and loaded into RAM and then into CPU for execution. Among those programs is a client program that receives messages from, and transmits messages to, other workstations connected to the network.

Web search engines such as Google, Yahoo, and MSN Search index the entire content of a web page typically every few days. However, for weblogs, users want to be able to search over individual posts, and in near real-time. Weblog search portals such as Technorati, Feedster, Pub Sub and BlogPulse have gained in popularity over the past year and a half, as people begin to turn to weblogs to get up-to-the-minute breaking news and to get fresh angles on news stories.

In addition, marketers have awakened to the possibility of mining consumer sentiment from weblogs. In order to produce accurate analytics, it is first necessary to be to identify individual weblog posts. Examples of consumer sentiment analytics are the buzz surrounding a product (number of mentions), number of links to a company website, trends in number of mentions and number of links, and ratio of positive vs. negative mentions. Glance, M. Hurst, K. Nigam, M. Siegler, R. Stockton, and T. Tomokiyo. Analyzing online discussion for marketing intelligence. In Proceedings WWW-2005, Chiba, Japan, 2005 (incorporated herein by reference).

Researchers as well are turning to blogs to gauge opinion and community structure. For example, Adamic and Glance recently analyzed the linking behavior of political bloggers during the 2004 U.S. Presidential Election and found that conservative bloggers link to each other more frequently and in a denser pattern than liberal bloggers. Adamic and N. Glance, The political blogosphere and the 2004 U.S. election: Divided they blog, In Proceedings WWW-2005 2nd Annual Workshop on the Weblogging Ecosystem, Chiba, Japan, 2005 (incorporated herein by reference). Marlow has studied the structure and authority in weblogs using inter-post citation counts. Marlow. Audience, structure and authority in the weblog community, In International Communication Association Conference, New Orleans, La., 2004 (incorporated herein by reference). Adar et. al. have explored how memes thread through the blogsphere from post to post. Adar, L. Zhang, L. A. Adamic, and R. M. Lukose, Implicit structure and the dynamics of blogspace, In Proceedings WWW-2004 Workshop on the Weblogging Ecosystem, New York City, N.Y., 2004 (incorporated herein by reference). The Global Attention Profiles project tracks the attention that bloggers pay to different nations of the world, in comparison with selected mainstream media outlets.

To enable sophisticated analytics over weblogs, a blog search engine typically uses an indexing mechanism that indexes a weblog one post at time, as opposed to one HTML page at a time. In order to index blogs one post at a time, the indexing system should be able to segment the weblog HTML into individual posts and extract meta-data associated with the posts, such as the posting date, title, permalink, and author.

The present invention provides a method for segmenting weblogs into individual posts using a combination of weblog feeds (such as RSS and Atom) and model-based wrapper segmentation. RSS is a family of web feed formats, specified in XML and used for Web syndication. Web feeds provide web content or summaries of web content together with links to the full versions of the content, and other metadata. RSS, in particular, delivers this information as an XML file called an RSS feed, webfeed, RSS stream, or RSS channel. In addition to facilitating syndication, web feeds allow a website's frequent readers to track updates on the site using an aggregator. Atom is the name of a specific web feed format. Web feeds, from a user's perspective, allow Internet users to subscribe to websites that change or add content regularly. Web feeds in general provide web content or summaries of web content together with links to the full versions of the content, and other meta-data in a developer-friendly standardized format Atom, from a technical perspective, is an open standard that includes an XML-based web syndication format used by weblogs, news websites and web mail.

2. Definitions

The following definitions are used throughout this description:

Weblog or blog: a weblog is a website where an individual or group of individuals publishes posts periodically. The posts are usually displayed in reverse chronological order. Each post generally consists of: a date, a title, the body of the post, a permalink to the post, an author, and one or more categorizations.

Weblog entry: a post or a set of posts published on a specific day.

Post: item published to weblog at a specific time of day.

Weblog feed/syndication: weblogs may or may not make posts available via syndication using RSS or Atom feeds. Web feeds provide web content or summaries of web content together with links to the full versions of the content, and other metadata. Atom feeds are XML documents. In addition, there are several versions of the RSS standard in use.

Weblog host: a company or website that hosts weblogs for individuals. Examples of popular weblog hosts are: livejournal.com, xanga.com, spaces.msn.com, blogspot.com, and the family of per-country domain typepad hosts.

Weblog software: software that enables creation and publishing of weblog posts to a weblog host, or to a self-hosted weblog. Each weblog host has its own weblog software tool for publishing posts. In addition, there are a number of weblog software tools for publishing a self-hosted weblog, such as Typepad, Moveable Type, and Wordpress.

Weblog ping: A weblog ping is an XML-RPC mechanism that notifies a ping server, such as weblogs.com or blo.gs, that the weblog has changed (e.g., the author has written a new post). Many weblog software tools can be set (or are automatically pre-set) to ping centralized servers whenever the weblog is updated. Example ping servers are http://blogs/ping.php and http://rpc.technorati.com/rpc/pingl. Some ping servers accept “extended pings” that include both the URL and feed URL of the updated weblog.

Crawl: A web crawler (also known as a web spider or web robot) is a program which browses the World Wide Web in a methodical, automated manner. A web crawler is one type of bot, or software agent. In general, it starts with a list of URLs to visit, called the seeds. As the crawler visits these URLs, it identifies all the hyperlinks in the page and adds them to the list of URLs to visit, called the crawl frontier. URLs from the frontier are recursively visited according to a set of policies.

Screen scraping: a technique in which a computer program extracts data from the display output of another program. The program doing the scraping is called a screen scraper. The key element that distinguishes screen scraping from regular parsing is that the output being scraped was nominally intended for human consumption, not machine interpretation. There are a number of synonyms for screen scraping, including: Data scraping, data extraction, web scraping, page scraping, and HTML scraping (the last three being specific to scraping web pages).

Wrapper: a program that performs screen scraping.

“Document Object Model” (DOM): a description of how an HTML or XML document is represented in an object-oriented fashion. DOM provides an application programming interface to access and modify the content, structure and style of the document.

Permalink: a term used in the world of blogging to indicate a URL which points to a specific blog entry.

XPath (XML Path Language): a terse (non-XML) syntax for addressing portions of an XML document.

3. Process for Extracting Posts from a Weblog

Here we describe a process for extracting individual posts from a weblog, according to an exemplary embodiment of the present invention. First we describe the typical layout of a weblog.

3.1. Modelling Weblogs

FIG. 1 shows the home page of a well-known weblog. Notice the extraneous content on the page: header, footer (not displayed) and sidebars (in this example, ads). However, the main content is a sequence of entries ordered in reverse chronological order, with each entry consisting of sequence of posts, also in reverse chronological order.

A weblog can be described formally as follows:

• • Weblog: Entry+
  • Entry: Date Post+
  • Post: Title? Content Permalink? Author? Timestamp? Link to comments? Categories*

The ordering of the sub-elements for the Entry elements and the Post elements is typically not standardized across weblogs, although it is assumed to be fixed within a weblog.

Also, the model assumes that the entry dates are monotonically decreasing.

3.2. Weblog Syndication

Many weblog publishing software tools also publish a feed in association with the weblog. The feed is updated whenever a new item is posted to the weblog. The feed is a “pull” mechanism, as is the weblog page. As a “pull” mechanism, the feed is accessed in order to find out if the weblog has been updated. However, feeds are designed to be read via a feed reader/aggregator (such as Bloglines, NewsGator, etc. or via an extension to a mail reader), which polls the feed on the behalf of the user(s). Thus, the end user who reads feeds via a feed reader experiences weblogs as a “push” phenomena: the newly published weblog posts are pushed to the user's screen.

Some weblog software tools have provided customization of the weblog's feed: the publication of the feed can be turned on or off, the feed can be updated whenever a new item is posted or modified, and the feed can be full content or partial content. Full vs. partial content is an important distinction. We define a full content feed as a feed that publishes the entire content of the post as viewable on the front page of the weblog. We define a partial content feed as a feed that publishes a summary of the post content available via the weblog.

With respect to feed publication, weblog software tools fall into three categories: (1) automatic generation of feeds (partial or full); (2) customized generation of feeds; or (3) no feed generation capability. In the last case, some tech-savvy bloggers will use custom software to create a feed and associate it with their weblog, or turn to a third-party feed generator to host a feed for the weblog (e.g., FeedBurner: http://www.feedburner.com/).

3.3. Segmenting Weblogs into Posts

This section describes our approach for segmenting weblogs into posts, according to an exemplary embodiment of the present invention. It would be costly to manually create individual wrappers for each weblog. However, weblogs tend to conform to a common model, as described in Section 3.1 above. Thus, we have focused on developing an approach that generalizes well over the majority of weblogs.

If a full content feed is available for a weblog, then the task of extracting posts from the weblog is the straightforward mapping of the XML format to an internal format. If a partial content feed exists for a weblog, then we use the partial content to guide the extraction process. If no partial content feed exists for a weblog, then we apply a model-based approach to extracting posts from the weblog page, taking advantage of regularities more or less common to most weblogs. Our work on model-based segmentation is similar to that of Nanno et al. Nanno, Automatic collection and monitoring of Japanese weblogs, In Proceedings WWW-2004 Workshop on the Weblogging Ecosystem, New York City, N.Y., 2004 (incorporated herein by reference).

Accordingly, here is an outline of the algorithm used for extracting posts from a weblog, according to an exemplary embodiment of the present invention:

• • 1. Crawl home page of weblog.
  • 2. Discover feed(s) associated with weblog
  • 3. For each feed:
    • (a) Determine if feed satisfies minimal requirements for proceeding. Our feed finder considers an item in the feed sufficient if it contains, at minimum, the following fields: date-posted AND (content OR description).
    • (b) If the feed is sufficient, classify the feed as full content or partial content.
    • (c) If feed is full content, then we map the data found in the feed into a representation for weblog posts.
    • (d) If feed is partial content, then use feed data to guide screen scraping of the weblog to construct a representation for weblog posts.
    • (e) If the feed has insufficient content, then try next feed associated with weblog.
  • 4. If there are no feeds with sufficient full or partial content, then fall back on screen scraping of weblog. Screen scraping uses a model-based approach to segment the weblog page into posts using textual and HTML elements of the page as markers.

3.4. Feed Discovery

After reaching the home page of the weblog, the first step consists of discovering the feed(s) for the weblog. If the weblog update was collected from a ping server relaying extended pings, and if the accepted ping includes the feed URL for the weblog, then we have located the feed. Alternatively, if the weblog is hosted by a weblog host which publishes full content feeds for its weblogs, then we need only map the weblog URL to the feed URL.

Otherwise, the next step in discovering the feed(s) for a weblog is to use “RSS auto-discovery.” RSS auto-discovery is an agreed-upon standard for specifying the location(s) of a weblog feed(s) as metadata in the HTML for the weblog home page.

If RSS auto-discovery fails to find a set of feeds for the weblog, the next step is to search for links to feeds from body of the weblog. First, all hyperlinks are extracted from the weblog. Next, the set of extracted hyperlinks are filtered using a classifier to identify which one(s) belong to the set of feeds for the weblogs. Currently, we use a set of heuristics to identify the feed(s) for a weblog from the extracted hyperlinks. The following is a non-exclusive list of criteria that can be used to identify the feed:

• • URLs that allow readers to subscribe to the feed in their RSS reader; these urls match “?url=?” or “bloglines.com/sub/”
  • URLs with one of a set of common feed suffixes, including {“atom.xml”, “.xml”, “.rss”, “rdf”, . . . } AND matching the host name of the blog
  • URLs with a host with one of a set of common feed prefixes, including {“xml”, “rss”, . . . } AND matching the domain name of the blog.

3.5. Full Content Vs. Partial Content Feeds

The multiple XML standards for weblog feeds (several versions of RSS and Atom) all satisfy the following minimal conditions:

• • The feed has the following top-level fields: weblog url, weblog title
  • The feed consists of a set of items (which for weblogs, correspond to posts). Each item may have the following fields: date-posted, permalink, post title, author, content, description

Our feed finder considers an item in the feed content to be sufficient if it contains, at minimum, the following fields: date-posted AND (content OR description). If no items in the feed contain sufficient content, the feed is rejected and weblog segmentation falls back upon model-based weblog segmentation (aka screen scraping).

The actual names of the fields depend on the feed standard being used. For example, for RSS v0.91, date-posted maps onto the XPath/item/title; content maps onto the XPath/item/description; and description maps onto the XPath/item/description. (There is no separate content field in the RSS v0.91 specification.)

Typically, the description field is used to provide a summary of the post (usually the first few lines) while the content field is used to provide either the full content of the post or a summary. Some feeds contain both, in which case, typically, the description contains the summary and the content contains the full post.

The feed classifier, which classifies the feed as full content or partial content, takes as input features of the content and description text, such as: presence/absence of HTML tags, % posts ending in ellipses, and type of feed. Based on these features, it uses heuristics decides whether or not the items in the feed are full content. Other features could be added, such as the variance in the length of text, etc.

If the feed is classified as full content, then we map the data found in the feed into our own internal representation for weblog posts, using XML representation of the content of the post+meta-data. Elements in the XML representation include: weblog url, permalink, weblog title, post title, date posted, time posted, and content.

If the feed is not full content, then we create skeletal posts from the data in the feed. For each post, we fill in the following data: weblog url; date-posted; partial content; post title (if found); post author (if found); and permalink (if found).

3.6. Feed-Guided Weblog Segmentation

The next step is to fill in the skeletal posts constructed from the feed by using the content of the weblog page itself. Missing from the skeletal posts is the full content of the post. To find the full content, the partial content is first processed to remove summarization artifacts (e.g., ending ellipsis). Then, we search for the partial content in the weblog. If the partial content is not found, then we will omit that particular post from our segmentation because not enough information can be located to construct the post. If we end up finding insufficient information on all posts, then we will fall back on model-based segmentation.

If the partial content matches text on the weblog home page, then we find the enclosing node for the matching text in the tidied XHTML for the weblog page. The Extensible HyperText Markup Language, or XHTML, is a markup language that has the same expressive possibilities as HTML, but a stricter syntax. The text inside the enclosing node is then used as the content for the post. If enclosing nodes for successive posts overlap, then we throw an error indicating that feed-guided segmentation has failed for the weblog, and, again, fall back on model-based segmentation.

3.7. Model-Based Weblog Segmentation

If there are no feeds with sufficient full or partial content, then we attempt to segment the weblog into posts using screen scraping of the weblog. Screen scraping uses a model-based approach to segment the weblog page into posts using textual and HTML elements of the page as markers.

Model-based weblog segmentation assumes that weblogs can be modeled as described in Section 3.1. Our approach then starts from a simplification of that model: (date ([title] content)+)+. This model assumes that dates appear first. This means that if we are able to extract the weblog entry dates, then we can use the dates as markers for the entries. Of course, a weblog page may have many other dates apart from the dates marking the entries: dates in the content of the posts; dates in the sidebars or in other non-weblog content included in the HTML page. However, as weblogs are produced by weblog software, we can expect certain regularities in the underlying DOM of the generated HTML. In particular, we expect that the relative XPaths of the weblog entry dates to be identical. A relative XPath is an Xpath that is defined relative to a location (XML node) in an XML document. In practice we've found that the relative XPaths of the entry dates are identical if we ignore certain elements in the XPath:/align/and repeating/font/s.

The first step in our model-based segmentation algorithm consists of extracting all the dates from the tidied XHTML for the weblog page using a date extractor. The dates are sorted into ordered lists, one list for each unique relative XPath. The order within the list corresponds to the ordering of the dates with the DOM for the weblog page.

We then filter the lists according to a set of heuristics in order to identify which list corresponds to the actual weblog entry dates. The filtering process for the date lists can be performed using the following sequence of steps:

• • 1. Keep only lists whose dates all belong to the current year and/or the past year.
  • 2. Keep only non-singleton date lists.
  • 3. Keep only lists whose dates conform to a similar format (e.g. MM/DD/YYYY).
  • 4. Keep only lists whose dates decrease monotonically.
  • 5. Keep only lists with most recent dates (but not in the future).
  • 6. Keep only lists with longest date string representation.
  • 7. Keep only lists with the greatest number of dates.
  • 8. Keep only first list.

One might think that after step 5 in the filtering process, we would be left with at most one list of dates. In practice, this is frequently not the case, because weblogs often have a sidebar with a dated list of recent posts which corresponds exactly the full set of posts in the main part of the weblog. The last few filtering steps help correctly identify the weblog entry dates as opposed to the dates in the sidebar.

If we fail to find a conforming list of dates, then model-based segmentation fails. There are some known cases where our approach fails: when only one entry appears on the home page of the weblog; or when weblog software for some reason generates irregular XPaths for the dates and/or content. But in many cases, segmentation fails when the HTML page in question is not actually a weblog. Thus, our model-based segmentation algorithm has the additional functionality of serving as a classifier that identifies whether or not an HTML page is indeed a weblog.

Once we have identified the entry dates for the weblog, model-based segmentation proceeds as follows:

• • 1. Segment weblog into entries, using dates as markers.
  • 2. Segment each weblog entry into posts using post titles markers.
  • 3. For each post, identify permalink and author.

In step 1, we assume that all DOM nodes between subsequent entry dates form the weblog entry associated with the earlier date. The main difficulty is identifying the end of the last post. For this we use a set of heuristics to identify the end of the blog entry by looking for the start of boilerplate weblog end template. Example end markers include: the start of a sidebar, a copyright notice, or a form, or a comment. Another heuristic for finding the end of the blog entry is to look for a node in the DOM whose XPath is analogous in structure to the XPath of the last node in the previous weblog entry.

In step 2, we attempt to use post titles to demarcate boundaries between posts for an entry. First, we iterate over the nodes of the entry searching for a node that matches one of our conditions for being a title node. These conditions include: class attribute of the node equals ‘title’ or ‘ subtitle’ or ‘blogpost’, etc. Once we have found the first matching title, we then assume that all subsequent post titles will have the same relative XPath. Again, we assume that all DOM nodes between subsequent title nodes are associated with the earlier title.

If we are unable to find titles, then we treat the entire entry as a single post. In fact, we have found that the majority of bloggers do not post more than once per day.

The final post-processing step identifies the permalink and author from the content of each extracted post using common patterns for permalinks and author signatures. To find authors, we look for patterns like “posted by.” To find permalinks, we look for hrefs (hyperlinks) in the post content that match, for example, “comment” or “archive.” Some patterns are given higher priority than others for matching against permalinks.

A weakness of our current implementation of model-based wrapper segmentation is that it assumes that the date field comes first in a weblog entry. In fact, while most blogs exhibit the pattern date ([title] content)+, others use (title date content)+ or even ([title] content date)+. Our approach is still able to segment blogs exhibiting these less common patterns, although the segmentation associates the date with the incorrect content. That is, if we have a sequence of N posts (post 1 through post N), the date for post 1 will be associated with the content of post 2 and so on. In addition, we will fail to extract the content of post 1. We call this error a parity error.

4. Segmentation Statistics

We have implemented weblog segmentation as part of the BlogPulse weblog post collection, indexing and search system.

In tests of the model-based segmentation algorithm, we have found that the precision of this algorithm is about 90%—that is about 90% of extracted posts have date, title and content fields that correspond to those of actual posts on the weblogs. The recall is approximately 70%—that is, we are able to extract posts from about 70% of true weblogs.

TABLE 1

Segmentation statistics for Apr. 13, 2005
Segmentation method      % of weblogs

Full content feed        78%
Feed-guided segmentation 11%
Model-based segmentation 11%

Table 1 shows the statistics for our segmentation process, the percentage of weblogs segmented using: (1) full content feeds (78%); (2) feed-guided segmentation (11%); or (3) model-based segmentation (11%).

We have implemented our segmentation algorithm as part of the weblog post collection subsystem of BlogPulse. This enables BlogPulse to provide search over individual blog posts. Furthermore, the corpus of dated weblog posts serves as a data set for tracking trends over time, and for analyzing how memes spread through the blogosphere.

Having described the invention with reference to embodiments, it is to be understood that the invention is defined by the claims, and it is not intended that any limitations or elements describing the embodiments set forth herein are to be incorporated into the meanings of the claims unless such limitations or elements are explicitly listed in the claims. Likewise, it is to be understood that it is not necessary to meet any or all of the identified advantages or objects of the invention disclosed herein in order to fall within the scope of any claims, since the invention is defined by the claims and since inherent and/or unforeseen advantages of the present invention may exist even though they may not have been explicitly discussed herein.

Claims

1. An apparatus, comprising:

at least one memory;

instructions; and

processor circuitry to execute the instructions to:

access a home page of a weblog;

identify a feed associated with the weblog;

determine whether items in the feed contain sufficient content for feed-guided segmentation;

when the items in the feed contain sufficient content for feed-guided segmentation, determine whether the items in the feed contain full content of the weblog;

when the items in the feed contain full content of the weblog, map data found in the feed into a representation of a weblog post; and

when the items in the feed contains partial content, screen scrape the weblog into the representation of the weblog post.

2. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to receive a feed URL for the weblog from a ping relayed by a ping server from which a weblog update is collected.

3. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to, when the weblog is hosted by a weblog host that publishes a full content feed for the weblog, map a URL of the weblog to a feed URL.

4. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to use RSS auto-discovery to identify a URL of the feed from metadata in HTML, for the home page of the weblog.

5. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to:

extract a set of hyperlinks from a body of the weblog; and

filter the set of extracted hyperlinks to identify hyperlinks that belong to the feed for the weblog.

6. The apparatus of claim 5, wherein the processor circuitry is to execute the instructions to use a set of heuristics to filter the set of extracted hyperlinks to identify the feed for the weblog from the extracted hyperlinks.

7. The apparatus of claim 5, wherein the processor circuitry is to execute the instructions to identify the feed for the weblog based on at least one of a URL that allow readers to subscribe to the feed in an RSS reader, a URL matching a host name of the weblog and having a common feed suffix including at least one of atom.xml, .xml, .rss, or rdf, or a URL matching a domain name of the weblog and having a common feed prefix including at least one of xml or rss.

8. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to determine the feed contains content for feed-guided segmentation when an item in the feed contains a date field and at least one of a content field or a description field.

9. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to determine whether the feed contains full content or partial content of the weblog based on heuristics and features of content and description text in the feed.

10. The apparatus of claim 9, wherein the features of the content and the description text include at least one of a presence or absence of HTML, tags, a percent of posts ending in ellipses, or a type of feed.

11. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to, when the feed contains partial content of the weblog, create the representation of the weblog post based on data available from the feed.

12. The apparatus of claim 11, wherein the representation includes at least one of a URL of the weblog, a date on which the weblog post was posted, partial content of the weblog post, a title of the weblog post, an author of the weblog post, or a permalink of the weblog post.

13. The apparatus of claim 12, wherein the processor circuitry is to execute the instructions to search the home page of the weblog for content matching the representations.

14. The apparatus of claim 13, wherein the processor circuitry is to execute the instructions to:

upon finding content on the home page of the weblog matching the representations, identify an enclosing node associated with the content matching the representations in extensible HyperText Markup Language (XHTML) for the home page of the weblog; and

extract text contained within the enclosing node to supplement the representation.

15. The apparatus of claim 12, wherein the processor circuitry is to execute the instructions to exclude summarization artifacts and advertisements from the representations.

16. The apparatus of claim 1, wherein the processor circuitry is to execute the instructions to extract dates from XHTML for a page of the weblog, and wherein when the feed contains insufficient content for feed-guided segmentation, the processor circuitry is to execute the instructions to:

sort the extracted dates into ordered lists, each ordered list corresponding to a relative XPath;

filter the ordered lists according to a set of heuristics to determine which of the lists correspond to entry dates of the weblog post;

segment the weblog into entries based on dates from the determined list as markers for the entries;

extract the weblog post from the weblog entries based on post title markers; and

identify a permalink and an author for the weblog post.

17. The apparatus of claim 16, wherein, to filter the ordered lists based on the set of heuristics, the processor circuitry is to execute the instructions to:

extract lists whose dates all belong to the current year or the past year;

extract non-singleton date lists;

extract lists including dates that conform to a similar format;

extract lists including dates that decrease monotonically;

extract lists with most recent dates and without future data;

extract a list with a longest date string representation;

extract a list with a greatest number of dates; and

extract a first list.

18. The apparatus of claim 16, wherein the processor circuitry is to execute the instructions to segment the weblog into entries based on a set of heuristics to identify an end of the weblog entries.

19. The apparatus of claim 18, wherein the set of heuristics includes at least one of a start of a sidebar on the page of the weblog, a copyright notice on the page of the weblog, a form, or a comment.

20. The apparatus of claim 19, wherein the processor circuitry is to execute the instructions to detect a node in a document object model whose XPath is analogous in structure to an XPath of a last node in a previous weblog entry.

21. The apparatus of claim 19, wherein the processor circuitry is to execute the instructions to:

search nodes of an entry to identify a title node;

determine that titles of subsequent posts have a same relative XPath as the title node identified in searching the nodes of the entry; and

in response to failing to identify a title node, determine that the entry is a single post.

22. The apparatus of claim 21, wherein the processor circuitry is to execute the instructions to identify the title node when a class attribute of the node is at least one of a title, a subtitle, or a blogpost.

23. The apparatus of claim 16, wherein, to identify the permalink and author, the processor circuitry is to execute the instructions to identify hrefs in content of the weblog post that match.

24. The apparatus of claim 16, wherein, to identify the permalink and author, the processor circuitry is to execute the instructions to identify patterns indicative of an author byline.

25. A computer readable storage device or storage disc comprising instructions that, when executed, cause a machine to at least:

access a home page of a weblog;

identify a feed associated with the weblog;

determine whether the feed contains sufficient content for feed-guided segmentation;

when the feed contains sufficient content for feed-guided segmentation, determine whether the feed contains full content or partial content of the weblog;

when the feed contains full content of the weblog, map data found in the feed into a representation of a weblog post; and

when feed contains partial content of the weblog, screen scrape the weblog into the representation of the weblog post.