Web Site Implementation by Mapping Expression Evaluation

• US 20110302267A1
• Filed: 06/08/2010
• Published: 12/08/2011
• Est. Priority Date: 06/08/2010
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Christensen, Erik Bo
• Granted Patent: US 8,645,490 B2
• Time in Patent Office: Days
• US Class Current: 709/217
• CPC Class Codes: G06F 16/9566 URL specific, e.g. using aliases, detecting broken or misspelled links
• CPC Class Codes: G06F 16/972 Access to data in other repository systems, e.g. legacy data or dynamic Web page generation
• CPC Class Codes: G06F 8/31 Programming languages or programming paradigms
• CPC Class Codes: H04L 67/02 based on web technology, e.g. hypertext transfer protocol [HTTP]

Abstract

Web sites are modeled using mappings from paths to expressions. A mapping data structure of expressions represents a web site'"'"'s hierarchical structure, and an enumerator, an array of characters, or an array of bytes represents the web site'"'"'s content. Expressions are written in a declarative programming language, and are lazily evaluated to provide results used in HTTP responses. A mapping may be recursive. An expression may contain a function call which returns contents of a file named in the HTTP request path, or the expression may evaluate to a text string, for example. Expressions may call functions which produce side-effects. An expression may recursively map a directory name to a mapping of a file name. Scalability is promoted by concurrently evaluating expression(s) on different machines in a stateless middle tier, and by streaming results. An arbitrarily large web site may be implemented in this manner.

Claims

1. A computer-readable non-transitory storage medium configured with data and with instructions that when executed by at least one processor causes the processor(s) to perform a process for implementing a web site, the process comprising the steps of:

receiving an HTTP request which includes a path;

mapping at least a portion of the path to locate an expression E in a nestable data structure which contains multiple expressions collectively representing the web site;

evaluating the expression E thereby obtaining a result R, while avoiding evaluating other expressions of the data structure; and

repeating the mapping and evaluating steps for successive expression(s) E and corresponding successive result(s) R until an evaluating step yields website content as a result R-final; and

then

generating an HTTP response to the HTTP request, the HTTP response containing the result R-final.

2. The configured medium of claim 1, wherein the expression E is written in a declarative (as opposed to imperative) programming language, and the evaluating step includes at least one of the following:

parsing the expression E with a parser based on at least a syntax rule of the declarative programming language;

executing a function which is invoked using a calling mechanism of the declarative programming language;

utilizing a lazy evaluation mechanism of the declarative programming language.

3. The configured medium of claim 1, wherein the mapping step includes at least one of the following:

mapping a file name to an expression containing a call to a function which returns contents of the file;

mapping a file name to an expression containing a call to a function which returns a text string;

mapping a file name to an expression which evaluates to a text string;

recursively mapping a directory name to a mapping of a file name;

recursively mapping a dynamically constructable record which includes at least one field-value pair.

4. The configured medium of claim 1, wherein the process evaluates at most a minimal portion of the data structure, namely, the portion whose evaluation is a precondition for generating the HTTP response, as indicated by declared dependency(ies).

5. The configured medium of claim 1, wherein the mapping step maps at least a portion of the path to an expression E in a data structure which is declared in a dynamically typed programming language.

6. The configured medium of claim 1, wherein the configured medium resides on different machines in a network, and the process comprises:

receiving at the different machines multiple HTTP requests from multiple sources;

concurrently evaluating expression(s) of the same data structure on the different machines;

concurrently generating respective HTTP responses; and

transmitting the respective HTTP responses toward the multiple sources.

7. The configured medium of claim 1, wherein the generating step generates an HTTP response containing a stream of web site content.

8. The configured medium of claim 1, wherein receiving, mapping, evaluating, and generating steps occur in a first instance for an HTTP request from a first user and also occur in a second instance for the same HTTP request from a second user, and wherein a result R1 of the first instance evaluating step differs from a result R2 of the second instance evaluating step.

9. A process for implementing a web site, the process comprising:

electronically declaring a computer data structure which maps portions of a Uniform Resource Indicator (URI) path to respective expressions, the declared data structure residing in and configuring a computer-readable storage medium; and

making digital web site content electronically accessible to a fully automatic evaluation mechanism which is operable to perform lazy evaluation of the expressions based on automatically located dependencies that have been made declaratively.

10. The process of claim 9, wherein the declaring step electronically declares at least one of the following:

a mapping from a file name to an expression containing a call to a function which returns contents of the file;

a mapping from a file name to an expression which evaluates to a text string;

a recursive mapping of a dynamically constructable record.

11. The process of claim 9, wherein the declaring step electronically declares the data structure in a version of an M programming language.

12. The process of claim 9, wherein the process implements an arbitrarily large web site, namely, a web site which has no fixed upper bound on storage size in the absence of lazy evaluation of the expressions.

13. The process of claim 9, wherein the process models the web site by providing the data structure to represent web site hierarchical structure, and by providing at least one of the following to represent web site content:

an enumerator, an array of characters, an array of bytes.

14. A computer system comprising:

at least one logical processor;

a memory in operable communication with the logical processor(s), the memory located in at least one machine;

a mapping residing in the memory which maps portions of a network application layer request to respective expressions which, upon evaluation, produce a response to the request;

a lazy expression evaluator residing in the memory and operable to evaluate an expression in response to a request to access a request portion which is mapped to the expression.

15. The system of claim 14, wherein the system further comprises at least one of the following:

an HTTP request, an FTP request, another network application layer request utilizing a hierarchical naming scheme; and

wherein the lazy expression evaluator is operable to evaluate an expression in response to the request.

16. The system of claim 14, wherein the system comprises copies of the lazy expression evaluator evaluating the same expression and residing on multiple machines in a stateless middle tier in a network.

17. The system of claim 14, wherein an expression in the mapping includes a call to a File-Contents function which is operable to return contents of a file as binary data.

18. The system of claim 14, wherein the system comprises and contains in memory:

a network application layer request identifying a file;

an expression to which the request is mapped; and

a result of a lazy evaluation of the expression, the result including metadata which specifies a content type for the file.

19. The system of claim 14, wherein the mapping is recursive.

20. The system of claim 14, wherein an expression in the mapping includes a call to a function which is operable to produce a side-effect.