New! View global litigation for patent families

US20130174000A1 - Methods for dynamic document generation - Google Patents

Methods for dynamic document generation Download PDF

Info

Publication number
US20130174000A1
US20130174000A1 US13619242 US201213619242A US2013174000A1 US 20130174000 A1 US20130174000 A1 US 20130174000A1 US 13619242 US13619242 US 13619242 US 201213619242 A US201213619242 A US 201213619242A US 2013174000 A1 US2013174000 A1 US 2013174000A1
Authority
US
Grant status
Application
Patent type
Prior art keywords
page
content
dynamic
token
web
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Abandoned
Application number
US13619242
Inventor
Keith Bernstein
Robert Kieffer
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Facebook Inc
Original Assignee
Facebook Inc
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/30Information retrieval; Database structures therefor ; File system structures therefor
    • G06F17/30861Retrieval from the Internet, e.g. browsers
    • G06F17/3089Web site content organization and management, e.g. publishing, automatic linking or maintaining pages
    • G06F17/30896Document structures and storage, e.g. HTML extensions
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/20Handling natural language data
    • G06F17/21Text processing
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/20Handling natural language data
    • G06F17/21Text processing
    • G06F17/22Manipulating or registering by use of codes, e.g. in sequence of text characters
    • G06F17/2247Tree structured documents; Markup, e.g. Standard Generalized Markup Language [SGML], Document Type Definition [DTD]
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/30Information retrieval; Database structures therefor ; File system structures therefor
    • G06F17/30861Retrieval from the Internet, e.g. browsers
    • G06F17/3089Web site content organization and management, e.g. publishing, automatic linking or maintaining pages
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/30Information retrieval; Database structures therefor ; File system structures therefor
    • G06F17/30861Retrieval from the Internet, e.g. browsers
    • G06F17/3089Web site content organization and management, e.g. publishing, automatic linking or maintaining pages
    • G06F17/30893Access to data in other repository systems, e.g. legacy data or dynamic Web page generation
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F17/00Digital computing or data processing equipment or methods, specially adapted for specific functions
    • G06F17/30Information retrieval; Database structures therefor ; File system structures therefor
    • G06F17/30861Retrieval from the Internet, e.g. browsers
    • G06F17/30899Browsing optimisation
    • G06F17/30902Browsing optimisation of access to content, e.g. by caching
    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRICAL DIGITAL DATA PROCESSING
    • G06F8/00Arrangements for software engineering
    • G06F8/40Transformations of program code
    • G06F8/41Compilation
    • G06F8/42Syntactic analysis
    • G06F8/427Parsing
    • HELECTRICITY
    • H04ELECTRIC COMMUNICATION TECHNIQUE
    • H04LTRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
    • H04L67/00Network-specific arrangements or communication protocols supporting networked applications
    • H04L67/10Network-specific arrangements or communication protocols supporting networked applications in which an application is distributed across nodes in the network
    • H04L67/1097Network-specific arrangements or communication protocols supporting networked applications in which an application is distributed across nodes in the network for distributed storage of data in a network, e.g. network file system [NFS], transport mechanisms for storage area networks [SAN] or network attached storage [NAS]

Abstract

Dynamic web page generation is optimized by reducing the processing overhead required to parse the web page HTML code for tokens and insert dynamic content. Using the invention, an HTML file for a dynamic web page need be read and parsed only once throughout the life of the server. A software object parses the HTML, decomposes the page into constituent pieces and saves them to data structures as byte streams, which are cached, along with the software object, rendering multiple disk accesses unnecessary when the page is reconstituted. For subsequent requests, the dynamic page is created from the cached version, which is shareable across users and across requests. The optimization reduces server resource usage for dynamic page generation to near zero. The invention is also applicable to other documents combining static and dynamic content that require composition tools for editing.

Description

    CROSS REFERENCE TO RELATED APPLICATIONS
  • [0001]
    This application is a continuation of U.S. application Ser. No. 12/719,354 filed on Mar. 8, 2010, which is a continuation of U.S. application Ser. No. 12/154,680 filed on May 23, 2008 and issued as U.S. Pat. No. 7,703,010, which is a continuation of and claims priority benefit under 35 U.S.C. §120 to U.S. patent application Ser. No. 10/203,037, filed Aug. 2, 2002 (published as U.S. Publ. No. 2003-0014443 A1) entitled “HIGH PERFORMANCE FREEZE-DRIED DYNAMIC WEB PAGE GENERATION,” which is the U.S. National Phase under 35 U.S.C. §371 of International No. PCT/US01/03424, filed Feb. 1, 2001 (published as WO 01/57721 A2), entitled “HIGH PERFORMANCE FREEZE-DRIED DYNAMIC WEB PAGE GENERATION,” which claims priority to U.S. Provisional Application No. 60/180,394, filed Feb. 4, 2000, entitled “HIGH PERFORMANCE FREEZE-DRIED DYNAMIC WEB PAGE GENERATION,” all of which are hereby incorporated herein by reference in their entirety.
  • COPYRIGHT NOTICE
  • [0002]
    A portion of the disclosure of this patent document contains material that is subject to copyright protection. The copyright owner has no objection to the reproduction by anyone of the patent document or the patent disclosure, as it appears in the Patent and Trademark Office file or records, but otherwise reserves all copyright rights whatsoever.
  • BACKGROUND OF THE INVENTION
  • [0003]
    1. Field of the Invention
  • [0004]
    The invention relates to processing of electronic documents. More particularly the invention relates to a method of optimizing generation of web pages having dynamic content.
  • [0005]
    2. Description of Related Technology
  • [0006]
    Today's Internet websites must deliver an ever-increasing amount of dynamic web page content. Dynamic web page generation is the process whereby a server computer creates HTML “on the fly” to send to a client computer (a Web browser). Dynamic web pages differ from static web pages in that the content of a dynamic web page can only be determined the moment a page request is received by the server computer. While a static web page might display a biography of Abraham Lincoln, content which can be created once and not changed anymore, such a web page and methodology would not be suitable for a web page which displayed the current price of oranges at five local supermarkets. The latter case requires that the server computer utilize dynamic information and compose that information into a web page to send to a client computer.
  • [0007]
    A common practice employed to aid in the creation of dynamic web pages is the use of HTML containing “tokens”, or “tokenized HTML”. A tokenized HTML file contains some never-changing static information, for example a page heading with the word “Welcome” in it, but also contains some dynamic or “live” areas; for example, an area after “Welcome” where the user's name is to be dynamically placed. This will allow each user to see a Web page that is customized for them. When Sally visits this web page she'll be greeted with a page title that says “Welcome Sally”, and when Joe visits this web page it will be titled, “Welcome Joe”. One of the major advantages of using tokens as placeholders for dynamic content is that they are extremely unobtrusive, allowing technical personnel such as programmers to make sure that dynamic content is placed in certain areas of the page without the necessity of embedding complicated source code in the HTML, which may be very confusing and distracting to someone such as a graphic designer, who is tasked with maximizing the page's aesthetic appeal.
  • [0008]
    To serve up dynamic web pages, a web server typically creates a dynamic page by loading up a static HTML page with a “token” or “placeholder” in the area where the user's name went. The tokens are of a known form; for example, “@UserName@,” so that they may be searched for quickly and uniquely. The server searches the page looking for the tokens that refer to dynamic content, e.g. “@UserName@.” Once the token has been located, the server replaces its text with the dynamically discovered text, e.g “Sally.” Replacing a token involves storing all of the text leading up to the token and concatenating it with the dynamic content and all of the text following the token. It must do this for each request it receives (each dynamic page that each user asks for).
  • [0009]
    Various methods of creating documents with varying content have been proposed. For example, J. Cooper, M. San Soucie, Method of generating document using tables storing pointers and indexes, U.S. Pat. No. 4,996,662 (Feb. 26, 1991) describe a document processing system having a system architecture that includes a control structure providing supervisory routines for controlling supervisory functions of the system and document manipulation routines for operating upon the documents.
  • [0010]
    R. Smith, D. Ting, J. Boer, M. Mendelssohn, Document management and production system, U.S. Pat. No. 5,181,162 (Jan. 19, 1993) disclose an object-oriented document management and production system in which documents are represented as collections of logical components that may be combined and physically mapped onto a page-by-page layout.
  • [0011]
    D. Dodge, S. Follett, A. Grecco, J. Tillman, Method and apparatus for document production using common document database, U.S. Pat. No. 5,655,130 (Aug. 5, 1997) describe a system and method for producing a variety of documents from a common document database. In the described system, source documents are decomposed into encapsulated data elements, in which a data element includes the actual content along with classifying data about the content. The encapsulated data elements are saved to a database, and can be later reassembled to form variation specific documents.
  • [0012]
    All of the systems described above involve the decomposition of source documents into smaller components, storing the document components in a database and reassembling the document components to form different variations of the source document, or completely new documents. While these systems facilitate the building of variation specific documents such as software documentation, and other engineering documents, they only involve combining and recombining static elements in various ways. The disclosed systems don't provide any way of generating a document “on the fly” that incorporates dynamically discovered information. Furthermore, none of the systems described concern themselves with optimizing the process of incorporating dynamic information into an online document by reducing the required computer resource usage.
  • [0013]
    Various other methods have been proposed for creating dynamic content in pages for delivery to a client over the Internet on the World-Wide Web (WWW). For example, JAVA SERVER PAGES from Sun Microsystems, Inc. of Menlo Park Calif. or ACTIVE SERVER PAGES from Microsoft Corporation of Redmond Wash. create all of the page content by having the page's Java or C++ server code write all of the page content to the client browser (the output stream). The major drawback of these solutions is that the server code and the page design (the HTML) are both contained in the same HTML file making it extremely difficult for non-programmers (e.g. graphic artists) to use popular page design tools to modify the content on these pages
  • [0014]
    The primary task of Internet Web server computers is to deliver content (Web pages) to client computers (Web browsers). These server computers are expected to perform these operations extremely rapidly because they are being besieged by, potentially, thousands and thousands of client requests per second. For this reason web developers attempt to reduce bottlenecks in the server software so that the server is performing up to its maximum capacity. The problem, then, arrives when many tokens in many dynamic pages need to be repeatedly replaced with dynamic content. Though the example in the preceding paragraph only contained a single token, the reality is that dynamic Web pages are normally far more complex than in this example, and might have 20 or more tokens.
  • [0015]
    Without any optimization, on each request, the server would have to re-read the base HTML file from disk, search and replace all occurrences of each token, and then write the newly created content stream to the client's return stream. The problem with this approach is that it is extremely time consuming. Even if the file is read from disk only once (i.e. it's cached) the act of replacing all occurrences of all tokens in the file is a very slow and very costly operation. It is so slow that it would likely be the primary bottleneck in the server software. Additionally, buying more hardware, bandwidth, etc. will not solve this problem because no matter how many machines were running concurrently, on each client request each web server would have to re-read and re-replace the page's content.
  • [0016]
    There exists, therefore, a need in the art for a way to reduce the processing overhead required to parse the HTML code of a web page that requires the incorporation of dynamic content in order to locate areas, identified by tokens, wherein the dynamic contented is to be inserted, and replacing the tokens with the dynamic content.
  • SUMMARY OF THE INVENTION
  • [0017]
    The invention provides a process in which an HTML file for a web page incorporating dynamic content is read and parsed once and only once throughout the life of the server. The dynamic HTML file is read from the server's local disk. A ContentComposer, a software object, parses the HTML and decomposes the page into its constituent pieces, which are stored in multiple data structures. The data structures and the ContentComposer are cached, allowing extremely rapid access. For subsequent page requests, the dynamic page is created from the in-memory version. This in-memory version can be shared across users and across requests. Reading and decomposing the HTML file and performing token replacement is so highly optimized that server resource usage, (memory, CPU, etc.) is near zero.
  • [0018]
    While the preferred embodiment provides a particular implementation directed to replacement of tokens in HTML files by a web server, it is generally applicable to any situation in which documents need to be
      • be editable using reasonable and current tools; and
      • be dynamic in that some of its content is static but other pieces of its content are created dynamically and will likely change from one creation to the next.
    BRIEF DESCRIPTION OF THE DRAWINGS
  • [0021]
    FIG. 1 provides a top-level block diagram of a process for optimizing generation of a computer readable document incorporating static and dynamic content, according to the invention;
  • [0022]
    FIG. 2 provides a block diagram of a sub-process for “freeze-drying” raw content from a document template, according to the invention;
  • [0023]
    FIG. 3 provides a block diagram of a plurality of data structures for storing the freeze-dried content of FIG. 2, according to the invention; and
  • [0024]
    FIG. 4 provides a block diagram of a sub-process for composing a document from the freeze-dried content of FIG. 3, according to the invention.
  • DETAILED DESCRIPTION Overview
  • [0025]
    A description of the details and function of the present invention is provided below. The source code listed in APPENDIX A, written in JAVA, details the implementation of a preferred embodiment of the invention. The patentee has no objection to the reproduction of the source code or other information for the purpose of obtaining and maintaining a valid patent. However, the patentee otherwise reserves all copyright interests.
  • [0026]
    The invention is embodied as both a process to be executed on a computer, typically a web server, and a computer program product providing computer readable program code means for executing the various steps of the process. The computer readable program code is embodied on a computer readable medium. The computer readable medium may be either fixed, such as a mass storage device or a memory, or it may be removable, such as a CD or a diskette. The invention is implemented through the use of conventional computer programming techniques well known to those skilled in the art. While the source code provided in the attached appendix is written in JAVA, other programming languages would also be suitable for programming the invention. While the invention is preferably programmed in an object-oriented language such as JAVA or C++, other embodiments, consistent with the spirit and scope of the invention, programmed in procedural languages or scripted languages, are also possible.
  • [0027]
    Referring now to FIG. 1, the invention provides a process for optimizing generation of a computer readable document incorporating static and dynamic content 10, particularly web pages being served up to a client in response to a request from a user. As previously mentioned, one of the most common ways of generating web pages having dynamic content is to start with a page template. Typically, the page template is a file of HTML code containing placeholders where the dynamic content is to be inserted. The placeholders usually consist of tokens. For example “@Username@” might be typically used as a placeholder for a user's name. When the template is created, or after it is edited, it is saved to disk, typically on a web server. Thereafter, the HTML file is read from the disk and parsed to locate the “live” or dynamic sections, which have been set off or reserved by the tokens. The invention provides a process in which the HTML file need be read from disk and parsed only once, unlike prior art methods, which require that the file be read and parsed every time a client requests the page.
  • File Reads
  • [0028]
    In the current embodiment of the invention, the HTML file is read from the disk 11 by means of a helper software object tasked with various utility file operations, such as reading in files, getting file lists and so on. Reading pages of “static” content is performed by a “getContent( )” method embodied in the helper object. The getContent (0 method of the helper object retrieves the raw HTML file and stores the raw content to the cache as a string. More detailed descriptions of the operation of the helper object and the “getContent( )” method are to be found by referring to the documentation provided in the enclosed Appendix.
  • Content Composer
  • [0029]
    When parsing the HTML file for caching and token replacement purposes, the goal is to separate the HTML file into its component static pieces, dynamic pieces, and replaceable token pieces. A common term of art for this process is “freeze-drying” 12. The invention provides a ContentComposer class that is the sole parser and manager of this freeze-dried content. Each HTML file has a separate instance of the ContentComposer object associated with it. In keeping with conventional methods of object-oriented programming, in which an object includes both instructions and the associated data, the ContentComposer object for a particular page includes the implementation logic and the raw content string. When a file is loaded, the helper object checks to see if a ContentComposer object exists for the file. If the file has no associated ContentComposer object, the helper object creates one 20. A global HashMap, held in the cache, provides storage for ContentComposer objects. Thus, following creation of the ContentComposer, the new ContentCompser object is stored to the global Hashmap. In this way, the deconstructed file data is effectively cached, so that it may be used on subsequent invocations 21.
  • [0030]
    After being cached, ContentComposer parses the HTML file by “decomposing” the raw code string, separating it into its various components 22. Components are one of three types:
      • blocks of immutable content containing no tokens;
      • lines of immutable content that surround tokens; and
      • token replacement values.
  • [0034]
    According to a preferred embodiment of the invention, a token comprises a string that starts and ends with the “@” characters and contains no embedded white space, newline characters, colons, semi-colons, or commas. However, the delimiting characters are a mere matter of choice, dictated in this case by the conventional manner of creating tokenized HTML code.
  • [0035]
    In some cases, only the token is replaced, in other cases, the entire line containing the token is replaced. For example, the method allows calling processes to replace the whole line of text that the token was on, which is a frequent operation for callers replacing <li> or <select> items.
  • [0036]
    As previously described, the helper object provides a raw code string to the ContentComposer for parsing. A setContents( ) method within the ContentComposer provides most of the parsing logic for the invention. The setContents( ) method parses the raw content string to locate delimiting characters. Upon locating a delimiting character, the parsing engine evaluates the string for the presence of the previously indicated illegal characters—white space, newline characters, colons, semi-colons, or commas. The presence of any illegal characters indicates that the delimiting character is not associated with a valid token. “@foo bar@” or “keith@iamaze.com” are examples of such invalid strings. As the various page components are identified, they are stored to one of several data objects that are also associated with the ContentComposer. After the page components are identified, the page is decomposed by saving the separate components to a plurality of data structures 23. These data structures are described in greater detail below. It should be noted that the process of separating the page into components and storing them in the data structures constitutes the process commonly known as “freeze-drying.” While, for the purpose of description, the data and the data structures are described separately from the logic and instructions, they are, in fact, all associated within a single ContentComposer object, which is held in the cache. Thus, as with the raw code string, the data structures containing the page components are effectively cached, eliminating the necessity of any further disk accesses when the HTML file is composed.
  • [0037]
    After the page components are cached, calling processes can ask the ContentComposer to perform token replacement, which it can do very fast: in 0-1 time, the tokens are stored in a HashMap as described below. The final part of SXContentComposer's lifecycle is when the caller asks the ContentComposer to “compose( )” itself, thus creating a page for download to a client 13. The compose( ) method itself provides additional important performance gains. Rather than recomposing the HTML into a string, and passing the string to the calling process, extremely wasteful of memory and processor time, the ContentComposer walks through the data structures and writes the data to an output stream as it is walking 14.
  • [0038]
    This implementation holds three primary data structures. It is necessary to hold this parsed data in three disparate, but linked, data structures because the data must be accessed from a number of different “angles”, and for a number of different purposes. The composer will need access to all the original static text, plus some way to gather the token replacement values. The caller will need to replace token values (by specifying the token name), or the whole line the token is appears on. The caller may also want to inspect the line a token appears on.
  • Data Structures
  • [0039]
    The three primary data structures are as follows:
  • [0040]
    The first is an array of immutable content broken up into “chunks” 30. Each chunk is either a text block with no “@foo@” tokens, or it is an integer object pointing to the index of a token replacement object, (SXTokenLine) which will supply the values (string) for that chunk.
  • [0041]
    The second data structure is also an array of immutable content: an array of the token-replacement-objects mentioned above 31, and pointed to by the chunks array. These token-replacement-objects are of type Token Line and they hold the static text that immediately precedes and follows a token. They also hold the raw token name itself (e.g. “@FooBar@”) as well as a pointer to an object stored within the third data structure, a structure that holds the replacement line or replacement value associated with this token. This final object is of type Token. While the names assigned to the various page component types in the current embodiment are descriptive of their content, they are primarily a matter of choice.
  • [0042]
    The third data structure is a HashMap with all the tokens from the raw content as keys and all the replacement values set by the calling process as the values 32. These replacement values are of type Token Object, which can hold a replacement line or a replacement value for a token.
  • [0043]
    Note that the immutable text chunks never change throughout the life of this object, while the values stored in the tokens and replacement values HashMap are likely to change every time content is created, since tokens and replacement values represent the dynamic portion of the content.
  • [0044]
    Furthermore, to reduce the overhead of future writes to streams, and to reduce the excessive creation of string objects, the static data in both the immutable text chunks array as well as the immutable token lines array is stored as byte( ) rather than string.
  • Compose( ) Method
  • [0045]
    The Compose( ) method of the ContentComposer writes each text chunk and token replacement value to an output stream in sequential order, creating a single, coherent, token-replaced text stream.
  • [0046]
    As the ContentComposer walks the immutable text chunks array 40, if it encounters an array entry that is a token rather than a chunk of text, instead of concatenating the actual token, it concatenates the value for the token found in the tokens and replacement values HashMap 41.
  • [0047]
    The specific process and data structures used by the ContentComposer are described in greater detail in the example provided below.
  • Example Sample Raw Content
  • [0048]
  • [0000]
    <html>
    <title> iAmaze Presentation Tool </title>
    <h1> Welcome to iAmaze, @UserName@! </h1>
    <br>
    <br>
    Would you like to work on the presentation you last worked on, named
    @LastPresentation@?
    <br>
    If so, click here.
    </html>

    Sample Raw Data Structures Created from Raw Content:
  • Immutable Text Chunks Array:
  • [0049]
  • [0000]
    immutableTextChunksArray[0] = “<html>
    <title>iAmaze Presentation Tool </title>”
    immutableTextChunksArray[1] = “new integer(0)” (use to look up, at
    index=0, this token's pre- & post- SXTokenLine line text objects in the
    “immutableTokenLines” array.)
    immutableTextChunksArray[2] = “! </h1>
    <br>
    <br>”
    immutableTextChunksArray[3] = “new Integer(1)” (index into
    “immutableToken|Lines” array, above and below)
    immutableTextChunksArray[4] = “?
    <br>
    If so, click-here. </html>”
  • Immutable Token Lines Array:
  • [0050]
  • [0000]
    ImmutableTokenLinesArray[0] = {SXTokenLine{prefix=
    “<hi>Welcome to iAmaze, ” suffix=”! </h1>”, pointer to
    SXToken object in the tokensAndReplacementValues}
    ImmutableTokenLinesArray[1] = {SXTokenLine{prefix=”Would you
    like to work on the presentation you last worked on, named: “,
    suffix=””,pointer to SXToken object in the
    tokensAndReplacementValues}
  • Tokens and Replacement Values HashMap:
  • [0051]
  • [0000]
    TokensAndReplacementValues={
    {“@UserName@”,SXToken{replacementForToken=null,
    replacementForTokenLine=null}},
    {“@LastPresentation@”, SXToken{replacementForToken=null,
    replacementForTokenLine==null}}}
  • [0052]
    Thus, the data structures for the example page appear as shown above immediately after the parsing or “freeze-dry” process. After being supplied values by calling process, for example, in response to a request from a user, two separate methods are called to replace the tokens with the new content:
  • [0053]
    After calls to:
  • [0000]
    anSXContentComposer.replaceLineContainingToken(“@UserName@”,“<
    h1> Welcome to work, Keith! </h1>”);
    anSXContentComposer.replaceToken(”@LastPresentation@”,“1999
    Harleys”);
  • [0054]
    The tokens and replacement values HashMap look as below:
  • [0000]
    tokensAndReplacementValues=
    {{“@UserName@”,SXToken{replacementFortoken=null,
    replacementForTokenLine=”<h1>Welcome to work, Keith!
    </h1>”}},
    {“@LastPresentation@”, SXToken {replacementForToken =
    “1999Harleys”, replacementForTokenLine=null}}}
  • [0055]
    The first call replaces the entire line containing the token. The second call replaces only the token. The immutable text chunks and the immutable token lines arrays remain the same, since they contain immutable data.
  • [0056]
    A call to SXContentComposer's Compose( ) or toString( ) methods generates the following:
  • [0000]
    <html>
    <title> iAmaze Presentation Tool </title> <h1> Welcome to work, Keith!
    </title> <br>
    <br>
    Would you like to work on the presentation you last worked on, named
    1999 Harleys? <br>
    If so, click here.
    </html>
  • [0057]
    The toString( ) method outputs a string to the output stream in a fashion similar to the Compose( ) method. More detailed description of the toString( ) method as well as the replaceLineContainingToken( ), and replaceToken( ) methods is to be found below.
  • [0058]
    The following is the source code for an implementation of the present invention, written in JAVA:
  • [0059]
    Although the invention has been described herein with reference to certain preferred embodiments, one skilled in the art will readily appreciate that other applications may be substituted without departing from the spirit and scope of the present invention. Accordingly, the invention should only be limited by the Claims included below.

Claims (1)

  1. 1. A process for optimizing generation of a computer readable document incorporating static and dynamic content, comprising the steps of:
    providing a template file of said document, said file resident on a mass storage device of a first computer;
    reading said template into memory;
    creating a content composer, said content composer comprising a first software object;
    parsing said template by said content composer;
    decomposing said template into separate page components by said content composer;
    converting said components into strings of computer readable code by said content composer;
    storing said strings to one or more data structures; and
    caching said data structures containing said page components.
US13619242 2000-02-04 2012-09-14 Methods for dynamic document generation Abandoned US20130174000A1 (en)

Priority Applications (6)

Application Number Priority Date Filing Date Title
US18039400 true 2000-02-04 2000-02-04
PCT/US2001/003424 WO2001057721B1 (en) 2000-02-04 2001-02-01 Dynamic web page generation
US10203037 US7398463B2 (en) 2000-02-04 2001-02-03 High performance freeze-dried dynamic web page generation
US12154680 US7703010B2 (en) 2000-02-04 2008-05-23 Systems and methods for dynamic document generation
US12719354 US8402368B2 (en) 2000-02-04 2010-03-08 Methods for dynamic document generation
US13619242 US20130174000A1 (en) 2000-02-04 2012-09-14 Methods for dynamic document generation

Applications Claiming Priority (3)

Application Number Priority Date Filing Date Title
US13619242 US20130174000A1 (en) 2000-02-04 2012-09-14 Methods for dynamic document generation
US14586743 US9785723B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation
US14586615 US9830399B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation

Related Parent Applications (1)

Application Number Title Priority Date Filing Date
US12719354 Continuation US8402368B2 (en) 2000-02-04 2010-03-08 Methods for dynamic document generation

Related Child Applications (4)

Application Number Title Priority Date Filing Date
PCT/US2001/003424 Continuation WO2001057721B1 (en) 2000-02-04 2001-02-01 Dynamic web page generation
US10203037 Continuation US7398463B2 (en) 2000-02-04 2001-02-03 High performance freeze-dried dynamic web page generation
US14586743 Continuation US9785723B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation
US14586615 Continuation US9830399B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation

Publications (1)

Publication Number Publication Date
US20130174000A1 true true US20130174000A1 (en) 2013-07-04

Family

ID=22660290

Family Applications (6)

Application Number Title Priority Date Filing Date
US10203037 Active 2022-03-15 US7398463B2 (en) 2000-02-04 2001-02-03 High performance freeze-dried dynamic web page generation
US12154680 Active 2021-02-26 US7703010B2 (en) 2000-02-04 2008-05-23 Systems and methods for dynamic document generation
US12719354 Active 2021-09-19 US8402368B2 (en) 2000-02-04 2010-03-08 Methods for dynamic document generation
US13619242 Abandoned US20130174000A1 (en) 2000-02-04 2012-09-14 Methods for dynamic document generation
US14586743 Active US9785723B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation
US14586615 Active 2022-02-10 US9830399B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation

Family Applications Before (3)

Application Number Title Priority Date Filing Date
US10203037 Active 2022-03-15 US7398463B2 (en) 2000-02-04 2001-02-03 High performance freeze-dried dynamic web page generation
US12154680 Active 2021-02-26 US7703010B2 (en) 2000-02-04 2008-05-23 Systems and methods for dynamic document generation
US12719354 Active 2021-09-19 US8402368B2 (en) 2000-02-04 2010-03-08 Methods for dynamic document generation

Family Applications After (2)

Application Number Title Priority Date Filing Date
US14586743 Active US9785723B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation
US14586615 Active 2022-02-10 US9830399B2 (en) 2000-02-04 2014-12-30 Methods for dynamic document generation

Country Status (2)

Country Link
US (6) US7398463B2 (en)
WO (1) WO2001057721B1 (en)

Cited By (2)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20150088970A1 (en) * 2013-09-20 2015-03-26 Yottaa Inc. Systems and methods for managing loading priority or sequencing of fragments of a web object
US9785723B2 (en) 2000-02-04 2017-10-10 Facebook, Inc. Methods for dynamic document generation

Families Citing this family (30)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
GB0008998D0 (en) * 2000-04-13 2000-05-31 Int Computers Ltd Template mechanism for document generation
US7171443B2 (en) * 2001-04-04 2007-01-30 Prodigy Communications, Lp Method, system, and software for transmission of information
EP1412874A4 (en) * 2001-07-27 2007-10-17 Quigo Technologies Inc System and method for automated tracking and analysis of document usage
US6665634B2 (en) * 2001-12-21 2003-12-16 Hewlett-Packard Development Company, L.P. Test system for testing dynamic information returned by a web server
US8201082B1 (en) 2002-06-17 2012-06-12 Amazon.Com, Inc. Dynamic generation of documents
US7386786B2 (en) * 2003-01-24 2008-06-10 The Cobalt Group, Inc. Method and apparatus for processing a dynamic webpage
US7062506B2 (en) 2003-01-24 2006-06-13 The Cobalt Group, Inc. Staged publication and management of dynamic webpages
US7178101B2 (en) * 2003-06-24 2007-02-13 Microsoft Corporation Content template system
GB0329824D0 (en) 2003-12-23 2004-01-28 Mandorla Technologies Ltd Editable information management system and method
US7451393B1 (en) * 2003-12-23 2008-11-11 Sun Microsystems, Inc. System and method for a page rendering framework
FR2882833A1 (en) * 2005-03-02 2006-09-08 Olivier Allouch Dynamic page transforming method, involves creating static segment files comprising static data segments and their identifiers, and replacing static segments by respective links, in dynamic page
US7680810B2 (en) * 2005-03-31 2010-03-16 Microsoft Corporation Live graphical preview with text summaries
US8122346B2 (en) * 2005-08-05 2012-02-21 Sap Ag Methods and systems for merging software-level objects with document-level objects in a document publishing environment
US7865527B2 (en) * 2006-03-30 2011-01-04 Oracle International Corporation Dynamic tables with dynamic rows for use with a user interface page
US20080005666A1 (en) * 2006-06-29 2008-01-03 Making Everlasting Memories, Llc System and method for publishing information and content
WO2008021864A3 (en) 2006-08-08 2008-07-03 Wayport Inc Real-time, customized embedding of specific content into local webserver pages
US8533291B1 (en) * 2007-02-07 2013-09-10 Oracle America, Inc. Method and system for protecting publicly viewable web client reference to server resources and business logic
US8904340B2 (en) * 2007-02-13 2014-12-02 International Business Machines Corporation Use of temporary optimized settings to reduce cycle time of automatically created spreadsheets
US20090119329A1 (en) * 2007-11-02 2009-05-07 Kwon Thomas C System and method for providing visibility for dynamic webpages
US20090217145A1 (en) * 2008-02-27 2009-08-27 Actionthis Limited Methods and devices for post processing rendered web pages and handling requests of post processed web pages
US20100287292A1 (en) * 2009-05-08 2010-11-11 Michael Ohman Meurlinger Method, apparatus and computer program product for generating a content website in a data communications network
GB0909695D0 (en) * 2009-06-05 2009-07-22 Maxymiser Ltd On page console
JP2011013985A (en) * 2009-07-02 2011-01-20 Internatl Business Mach Corp <Ibm> Program, apparatus and method
US20110082875A1 (en) * 2009-10-02 2011-04-07 Netquote, Inc. System and method for dynamic payload generation on shared sites
US8489772B2 (en) * 2010-03-09 2013-07-16 At&T Intellectual Property I, L.P. Method for mechanically generating content for messages
US8972418B2 (en) 2010-04-07 2015-03-03 Microsoft Technology Licensing, Llc Dynamic generation of relevant items
WO2013011730A1 (en) * 2011-07-21 2013-01-24 インターナショナル・ビジネス・マシーンズ・コーポレーション Device and method for processing document
EP2808794A1 (en) * 2013-05-30 2014-12-03 Siemens Aktiengesellschaft Rearranging a server response
US9529791B1 (en) * 2013-12-12 2016-12-27 Google Inc. Template and content aware document and template editing
CN104112002B (en) * 2014-07-14 2017-08-25 福建星网锐捷网络有限公司 Namely Forms adaptation method, apparatus and system for

Citations (19)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5572643A (en) * 1995-10-19 1996-11-05 Judson; David H. Web browser with dynamic display of information objects during linking
US5717913A (en) * 1995-01-03 1998-02-10 University Of Central Florida Method for detecting and extracting text data using database schemas
US5835914A (en) * 1997-02-18 1998-11-10 Wall Data Incorporated Method for preserving and reusing software objects associated with web pages
US5894554A (en) * 1996-04-23 1999-04-13 Infospinner, Inc. System for managing dynamic web page generation requests by intercepting request at web server and routing to page server thereby releasing web server to process other requests
US5937421A (en) * 1996-08-19 1999-08-10 International Business Machines Corporation Methods, systems and computer program products for performing interactive applications in a client-server based dialog system
US5968125A (en) * 1997-01-21 1999-10-19 Net. Roi Process for optimizing the effectiveness of a hypertext element
US5974416A (en) * 1997-11-10 1999-10-26 Microsoft Corporation Method of creating a tabular data stream for sending rows of data between client and server
US5987480A (en) * 1996-07-25 1999-11-16 Donohue; Michael Method and system for delivering documents customized for a particular user over the internet using imbedded dynamic content
US5999912A (en) * 1996-05-01 1999-12-07 Wodarz; Dennis Dynamic advertising scheduling, display, and tracking
US6012062A (en) * 1996-03-04 2000-01-04 Lucent Technologies Inc. System for compression and buffering of a data stream with data extraction requirements
US6012087A (en) * 1997-01-14 2000-01-04 Netmind Technologies, Inc. Unique-change detection of dynamic web pages using history tables of signatures
US6018748A (en) * 1996-05-28 2000-01-25 Sun Microsystems, Inc. Dynamic linkable labels in a network browser page
US6025844A (en) * 1997-06-12 2000-02-15 Netscape Communications Corporation Method and system for creating dynamic link views
US6038598A (en) * 1998-02-23 2000-03-14 Intel Corporation Method of providing one of a plurality of web pages mapped to a single uniform resource locator (URL) based on evaluation of a condition
US6055522A (en) * 1996-01-29 2000-04-25 Futuretense, Inc. Automatic page converter for dynamic content distributed publishing system
US6226642B1 (en) * 1997-09-11 2001-05-01 International Business Machines Corporation Content modification of internet web pages for a television class display
US6397217B1 (en) * 1999-03-04 2002-05-28 Futuretense, Inc. Hierarchical caching techniques for efficient dynamic page generation
US6678867B2 (en) * 1997-12-23 2004-01-13 Ricoh Company, Ltd. Method and apparatus for providing a graphical user interface for creating and editing a mapping of a first structural description to a second structural description
US6966027B1 (en) * 1999-10-04 2005-11-15 Koninklijke Philips Electronics N.V. Method and apparatus for streaming XML content

Family Cites Families (37)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5552982A (en) * 1990-10-31 1996-09-03 Microsoft Corporation Method and system for processing fields in a document processor
US5671436A (en) * 1991-08-21 1997-09-23 Norand Corporation Versatile RF data capture system
US5230173A (en) * 1991-10-07 1993-07-27 Riley Michael P Cellular phone index apparatus
US6230173B1 (en) * 1995-07-17 2001-05-08 Microsoft Corporation Method for creating structured documents in a publishing system
US5761673A (en) * 1996-01-31 1998-06-02 Oracle Corporation Method and apparatus for generating dynamic web pages by invoking a predefined procedural package stored in a database
US6006242A (en) 1996-04-05 1999-12-21 Bankers Systems, Inc. Apparatus and method for dynamically creating a document
US5715453A (en) * 1996-05-31 1998-02-03 International Business Machines Corporation Web server mechanism for processing function calls for dynamic data queries in a web page
US6112242A (en) * 1996-07-10 2000-08-29 Uln Corporation System and method for dynamic data interaction in a hypertext data processing system
US5991809A (en) * 1996-07-25 1999-11-23 Clearway Technologies, Llc Web serving system that coordinates multiple servers to optimize file transfers
US6658624B1 (en) 1996-09-24 2003-12-02 Ricoh Company, Ltd. Method and system for processing documents controlled by active documents with embedded instructions
US5974572A (en) * 1996-10-15 1999-10-26 Mercury Interactive Corporation Software system and methods for generating a load test using a server access log
US5897622A (en) * 1996-10-16 1999-04-27 Microsoft Corporation Electronic shopping and merchandising system
US5933606A (en) 1997-02-19 1999-08-03 International Business Machines Corporation Dynamic link page retargeting using page headers
US5983227A (en) * 1997-06-12 1999-11-09 Yahoo, Inc. Dynamic page generator
US6195097B1 (en) * 1997-07-08 2001-02-27 International Business Machines Corporation Web-based DCE management
US6021426A (en) 1997-07-31 2000-02-01 At&T Corp Method and apparatus for dynamic data transfer on a web page
US6256712B1 (en) * 1997-08-01 2001-07-03 International Business Machines Corporation Scaleable method for maintaining and making consistent updates to caches
US6055541A (en) * 1997-09-19 2000-04-25 Sas Ip, Inc. Automatic report generating system
US6023724A (en) * 1997-09-26 2000-02-08 3Com Corporation Apparatus and methods for use therein for an ISDN LAN modem that displays fault information to local hosts through interception of host DNS request messages
US6886130B1 (en) 1997-11-26 2005-04-26 International Business Machines Corporation Compiled structure for efficient operation of distributed hypertext
US5991713A (en) 1997-11-26 1999-11-23 International Business Machines Corp. Efficient method for compressing, storing, searching and transmitting natural language text
US6230168B1 (en) 1997-11-26 2001-05-08 International Business Machines Corp. Method for automatically constructing contexts in a hypertext collection
US6278449B1 (en) * 1998-09-03 2001-08-21 Sony Corporation Apparatus and method for designating information to be retrieved over a computer network
US6539370B1 (en) * 1998-11-13 2003-03-25 International Business Machines Corporation Dynamically generated HTML formatted reports
US6507867B1 (en) * 1998-12-22 2003-01-14 International Business Machines Corporation Constructing, downloading, and accessing page bundles on a portable client having intermittent network connectivity
US7111231B1 (en) * 1999-02-24 2006-09-19 Intellisync Corporation System and methodology for dynamic application environment employing runtime execution templates
US6791571B1 (en) 1999-02-27 2004-09-14 Microsoft Corporation Absolute and relative coordinate based format description system and method
US6470349B1 (en) * 1999-03-11 2002-10-22 Browz, Inc. Server-side scripting language and programming tool
US6606657B1 (en) * 1999-06-22 2003-08-12 Comverse, Ltd. System and method for processing and presenting internet usage information
US6671853B1 (en) * 1999-07-15 2003-12-30 International Business Machines Corporation Method and system for selectively streaming markup language documents
US20040102197A1 (en) * 1999-09-30 2004-05-27 Dietz Timothy Alan Dynamic web page construction based on determination of client device location
US7174506B1 (en) * 1999-11-05 2007-02-06 International Business Machines Corporation Method and system for producing dynamic web pages
US6718515B1 (en) * 1999-12-07 2004-04-06 International Business Machines Corporation Method of populating a dynamic HTML table from a set of data objects through a common interface
US8645211B2 (en) 2000-01-06 2014-02-04 Anthony R. Rothschild System and method for adding an advertisement to a personal communication
US6643652B2 (en) * 2000-01-14 2003-11-04 Saba Software, Inc. Method and apparatus for managing data exchange among systems in a network
WO2001052090A3 (en) * 2000-01-14 2001-12-13 Michael L Dufner Method and apparatus for a web content platform
WO2001057721B1 (en) 2000-02-04 2002-03-28 America Online Inc Dynamic web page generation

Patent Citations (19)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US5717913A (en) * 1995-01-03 1998-02-10 University Of Central Florida Method for detecting and extracting text data using database schemas
US5572643A (en) * 1995-10-19 1996-11-05 Judson; David H. Web browser with dynamic display of information objects during linking
US6055522A (en) * 1996-01-29 2000-04-25 Futuretense, Inc. Automatic page converter for dynamic content distributed publishing system
US6012062A (en) * 1996-03-04 2000-01-04 Lucent Technologies Inc. System for compression and buffering of a data stream with data extraction requirements
US5894554A (en) * 1996-04-23 1999-04-13 Infospinner, Inc. System for managing dynamic web page generation requests by intercepting request at web server and routing to page server thereby releasing web server to process other requests
US5999912A (en) * 1996-05-01 1999-12-07 Wodarz; Dennis Dynamic advertising scheduling, display, and tracking
US6018748A (en) * 1996-05-28 2000-01-25 Sun Microsystems, Inc. Dynamic linkable labels in a network browser page
US5987480A (en) * 1996-07-25 1999-11-16 Donohue; Michael Method and system for delivering documents customized for a particular user over the internet using imbedded dynamic content
US5937421A (en) * 1996-08-19 1999-08-10 International Business Machines Corporation Methods, systems and computer program products for performing interactive applications in a client-server based dialog system
US6012087A (en) * 1997-01-14 2000-01-04 Netmind Technologies, Inc. Unique-change detection of dynamic web pages using history tables of signatures
US5968125A (en) * 1997-01-21 1999-10-19 Net. Roi Process for optimizing the effectiveness of a hypertext element
US5835914A (en) * 1997-02-18 1998-11-10 Wall Data Incorporated Method for preserving and reusing software objects associated with web pages
US6025844A (en) * 1997-06-12 2000-02-15 Netscape Communications Corporation Method and system for creating dynamic link views
US6226642B1 (en) * 1997-09-11 2001-05-01 International Business Machines Corporation Content modification of internet web pages for a television class display
US5974416A (en) * 1997-11-10 1999-10-26 Microsoft Corporation Method of creating a tabular data stream for sending rows of data between client and server
US6678867B2 (en) * 1997-12-23 2004-01-13 Ricoh Company, Ltd. Method and apparatus for providing a graphical user interface for creating and editing a mapping of a first structural description to a second structural description
US6038598A (en) * 1998-02-23 2000-03-14 Intel Corporation Method of providing one of a plurality of web pages mapped to a single uniform resource locator (URL) based on evaluation of a condition
US6397217B1 (en) * 1999-03-04 2002-05-28 Futuretense, Inc. Hierarchical caching techniques for efficient dynamic page generation
US6966027B1 (en) * 1999-10-04 2005-11-15 Koninklijke Philips Electronics N.V. Method and apparatus for streaming XML content

Cited By (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US9785723B2 (en) 2000-02-04 2017-10-10 Facebook, Inc. Methods for dynamic document generation
US9830399B2 (en) 2000-02-04 2017-11-28 Facebook, Inc. Methods for dynamic document generation
US20150088970A1 (en) * 2013-09-20 2015-03-26 Yottaa Inc. Systems and methods for managing loading priority or sequencing of fragments of a web object
US9282145B2 (en) 2013-09-20 2016-03-08 Yottaa Inc. Systems and methods for managing loading priority or sequencing of fragments of a web object
US9870349B2 (en) 2013-09-20 2018-01-16 Yottaa Inc. Systems and methods for managing loading priority or sequencing of fragments of a web object

Also Published As

Publication number Publication date Type
US7703010B2 (en) 2010-04-20 grant
US20150205883A1 (en) 2015-07-23 application
WO2001057721A3 (en) 2002-02-28 application
US20160078145A9 (en) 2016-03-17 application
WO2001057721A2 (en) 2001-08-09 application
US9785723B2 (en) 2017-10-10 grant
WO2001057721B1 (en) 2002-03-28 application
US20080294682A1 (en) 2008-11-27 application
US20100162099A1 (en) 2010-06-24 application
US20150113366A1 (en) 2015-04-23 application
US9830399B2 (en) 2017-11-28 grant
US20030014443A1 (en) 2003-01-16 application
US7398463B2 (en) 2008-07-08 grant
US8402368B2 (en) 2013-03-19 grant

Similar Documents

Publication Publication Date Title
US7076766B2 (en) Software application development methods and framework
US6976209B1 (en) Activemark mechanism in a live parsing editor
US6647544B1 (en) Method and system for debugging hybrid source code
US6779152B1 (en) Method for rotating a dynamic HTML table
US6209029B1 (en) Method and apparatus for accessing data sources in a three tier environment
US5680622A (en) System and methods for quickly detecting shareability of symbol and type information in header files
US6249844B1 (en) Identifying, processing and caching object fragments in a web environment
US6012053A (en) Computer system with user-controlled relevance ranking of search results
US6173439B1 (en) Interface mechanism and method for accessing non-object oriented data from within an object oriented framework
US6535882B2 (en) System and method for facilitating a windows based content manifestation environment within a WWW browser
US5752022A (en) Method for creating a hypertext language for a distributed computer network
US7117436B1 (en) Generating a Web page by replacing identifiers in a preconstructed Web page
US5930795A (en) Supporting dynamic tables in SQL query compilers
US5497491A (en) System and method for importing and exporting data between an object oriented computing environment and an external computing environment
US7191186B1 (en) Method and computer-readable medium for importing and exporting hierarchically structured data
US6886130B1 (en) Compiled structure for efficient operation of distributed hypertext
US7607085B1 (en) Client side localizations on the world wide web
US6330566B1 (en) Apparatus and method for optimizing client-state data storage
US7152224B1 (en) Versioned project associations
US6538673B1 (en) Method for extracting digests, reformatting, and automatic monitoring of structured online documents based on visual programming of document tree navigation and transformation
US20020078041A1 (en) System and method of translating a universal query language to SQL
US6247018B1 (en) Method for processing a file to generate a database
US20040003388A1 (en) Preparation of a software configuration using an XML type programming language
US6675354B1 (en) Case-insensitive custom tag recognition and handling
US20080072238A1 (en) Object synchronization in shared object space

Legal Events

Date Code Title Description
AS Assignment

Owner name: AMERICA ONLINE, INC., VIRGINIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:BERNSTEIN, KEITH;KIEFFER, ROBERT;SIGNING DATES FROM 20020701 TO 20020702;REEL/FRAME:034922/0696

Owner name: AOL INC., VIRGINIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:AOL LLC;REEL/FRAME:034922/0796

Effective date: 20091204

Owner name: AOL LLC, VIRGINIA

Free format text: CHANGE OF NAME;ASSIGNOR:AMERICA ONLINE, INC.;REEL/FRAME:034925/0085

Effective date: 20060403

Owner name: FACEBOOK, INC., CALIFORNIA

Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:AOL INC.;REEL/FRAME:034925/0115

Effective date: 20120614