
“From”	sender name and email address
“FromAddress”	sender raw email address
“Subject”	the subject of the email address
“Body”	message body as a string
“Attachments”	list of processed attachments as expressions
“AttachmentData”	list of associations giving raw data on
	attachments
“ReceiverAddress”	email address of the mail receiver function
“ReceiverRoutingType”	whether the receiver is in “To”, “Cc”, or “Bcc”

Examples of parameters related to senders and recipients include:


	“FromName”	sender full name
	“ToList”	recipient names and addresses
		(except receiver function)
	“ToAddressList”	recipient addresses (except receiver function)
	“ToNameList”	recipient full names (except receiver function)
	“CcList”	copied recipient names and addresses
	“CcAddressList”	copied recipient addresses
	“CcNameList”	copied recipient full names
	“ReturnPath”	declared return path for the mail
	“ReplyTo”	reply-to name and address
	“ReplyToAddress”	reply-to address

Examples of parameters related to attachments include:


“Attachments”	list of expressions giving the content
	of attachments
“AttachmentNames”	list of names assigned to attachments
“AttachmentAssociations”	associations giving content and metadata
	of attachments

Examples of parameters related to message identification and threading include:


“MessageID”	message ID for this message
“ReplyToMessageID”	ID of a message to which this replies, if any

Examples of parameters related to message routing include:


“Precedence”	declared mail precedence
“ReturnReceiptRequested”	whether a return receipt is requested
“DeliveryChainHostnames”	hostnames on the mail delivery chain
“DeliveryChainRecords”	full records on the mail delivery chain

Examples of parameters associated with mail headers include:


	“HeaderString”	complete email headers as a string
	“HeaderRules”	list of rules for all headers
	“CharacterEncoding”	character encoding for email content
	“ContentType”	MIME content type of email body

Examples of parameters associated with message origination include:


“OriginatingMailClient”	type of originating mail client
“OriginatingIPAddress”	IP address of the originating client machine
“OriginatingHostname”	hostname of the originating client machine
“OriginatingCountry”	geoIP-inferred originating country
“OriginatingDate”	date and time on client from email headers
“OriginatingTimezone”	client time zone based on email headers
“ServerOriginatingDate”	date and time on originating server
“ServerOriginatingTimezone”	time zone of originating server

Examples of further parameters include:


	“Association”	a list of all identified parameters.

In an embodiment, the identified parameters are made available in respective formats and/or data types that are recognized by thecomputational application140, the cloud-based developmentfront end144, and/or the cloud-baseddevelopment system module188 as corresponding to various elements of email messages. The programmer input defining the function func may refer to these parameters using keywords, and thus the function func may utilize the parameters when evaluating.

FIG. 2 illustratesexample programmer input200 for evaluating emails, according to an embodiment. Theprogrammer input200 includes afirst portion204 that defines a function func to be applied to emails. Theprogrammer input204 corresponds to a function that i) searches a body of a first email for the string “table”, and ii) if the string “table” is found within the body of the first email, a new second email is sent that a) forwards the first email and b) indicates that the first email mentions a table. This may be useful, for example, if a user wishes to buy a table and thus wishes to analyze many emails to determine if any of them relate to selling a table. The use is notified (via the second email) whenever a first email is found that mentions the word “table”. Theprogrammer input204 includes keywords (e.g., Body, From) that indicate parameters corresponding to various elements of email messages. In an embodiment, thecomputational application140, the cloud-based developmentfront end144, and/or the cloud-baseddevelopment system module188 are configured to process emails to identify in the emails the parameters, and then make those parameters available to functions such as the function func illustrated inFIG. 2. Thus the function func may utilize the parameters when evaluating an email.

Theprogrammer input200 also includes asecond portion208 that causes the function, defined by thefirst portion204, to be applied to emails in a mailbox file. For example, the emails in the mailbox file may have been previously retrieved from a server (e.g., an email server) via a network.

FIG. 3A illustratesexample programmer input300 for evaluating emails, according to an embodiment. Theprogrammer input300 includes afirst portion304 that defines a function func to be applied to emails. Theprogrammer input304 corresponds to a function that i) searches a body of a first email for the string “table”, and ii) if the string “table” is found within the body of the first email, the information from the email (sender, prices extracted from the email, body of the message, attachments) is appended to data structure called “TablesForSale” having the following elements: “Seller”, “Prices”, “Date”, “Message”, and “Pictures”.

Theprogrammer input300 also includes asecond portion308 that causes the function, defined by thefirst portion304, to be applied to emails in a mailbox file. For example, the emails in the mailbox file may have been previously retrieved from a server (e.g., an email server) via a network. Emails in the mailbox file will thus be evaluated and information extracted from emails with the word “table” will be appended to the data structure TablesForSale.

FIG. 3B illustratesexample programmer input304 for evaluating the data structure TablesForSale and resultingoutput308, according to an embodiment. Theprogrammer input304 causes the elements “Prices” and “Date” to be retrieved from the data structure TablesForSale and displayed asoutput308.

Referring now toFIGS. 1-3B, in some embodiments, thecomputational application140 is configured to evaluate the programmer input, and thus the examples ofFIGS. 1-3B can be implemented in a standalone computer. In other embodiments, the examples ofFIGS. 1-3B are implemented in a client-server system.

As mentioned above, in some embodiments, functions such as described above can be deployed to network accessible storage. Illustrative embodiments of methods and systems for deploying and invoking deployed executable objects for processing email messages are now described.

Cloud Deployment

In various embodiments, a programming language includes built-in functions that facilitate one or more of deployment of objects to the cloud, access to objects in the cloud, and/or manipulation of objects in the cloud. In various embodiments, one or more of thecomputational application140, the cloud-based developmentfront end144, and the cloud-baseddevelopment system module188 are configured to evaluate such built-in functions to deploy objects to the cloud, access objects in the cloud, and/or manipulate objects in the cloud. In some embodiments, such functions that facilitate one or more of deployment of objects to the cloud are utilized in conjunction with built-in functions that facilitate analysis of electronic messages such as emails.

In an embodiment, a CloudDeploy function enables a programmer to deploy an expression to the cloud, where the deployed expression can be software code that can be executed (e.g., by the server152), data that can be accessed and/or manipulated, etc. The programming language defines the keyword “CloudDeploy” as indicating a particular built in function as described below, according to various embodiments. In various embodiments, one or more of thecomputational application140, the cloud-based developmentfront end144, and the cloud-baseddevelopment system module188 are configured to recognize the keyword “CloudDeploy” as indicating the particular built in function as described below. For example, in various embodiments, one or more of the following syntaxes are utilized:

CloudDeploy[expr]

In this example, an expression expr is deployed as a cloud object, and theserver152 assigns a universal resource identifier (URI) to the cloud object. In some embodiments, the URI may include a universally unique identifier (UUID), such as the UUID standardized by the Open Software Foundation (OSF) as part of the Distributed Computing Environment (DCE). The URI may be a universal resource locator (URL), in some embodiments. Evaluation of this function returns a handle to the cloud object. The cloud object can then be accessed using the handle.

CloudDeploy[expr, “uri”]

In this example, an expression expr is deployed as a cloud object at a given URI.

CloudDeploy[expr, CloudObject[“uri”]]

In this example, an expression expr is deployed to a given cloud object. CloudObject is a handle to a cloud object at a specified URI.

In some embodiments, CloudDeploy can be utilized with one or more suitable options. For example, in some embodiments, parameters can be utilized with CloudDeploy to specify how the deployed object is to be evaluated. For instance, in some embodiments, one or more parameters can be specified to indicate that the object is to be invoked in response to email messages corresponding to the object. As another example, one or more parameters can be specified to indicate one or more of i) the object is to be private to the user (e.g., the object can only be accessed by the user), ii) the object is to be public (e.g., the object is publicly available on the web), iii) the object is to be available to specified users, iv) the object is to be available to one or more classes of users, etc.

In some embodiments, techniques described in U.S. patent application Ser. No. 14/549,541, may be utilized for deployment of objects to the cloud, access to objects in the cloud, and/or manipulation of objects in the cloud, etc. U.S. patent application Ser. No. 14/549,541, filed on Nov. 20, 2014, entitled “Methods and Systems for Cloud Computing,” is hereby incorporated by reference.

FIG. 4 is a flow diagram of anexample method400 for deploying objects to a cloud environment to enable accessing the objects via a network. In some embodiments, themethod400 may be implemented at one or more computers, such as thecomputer102 and/or theserver152 ofFIG. 1. Merely for explanatory purposes,FIG. 4 is described in the context of themethod400 implemented by thecomputer102. In other embodiments, however, themethod400 may be implemented jointly at thecomputer102 and theserver152, at another suitable computer (not shown inFIG. 1), at one or more other computers/servers, etc.

In some embodiments, themethod400 may be implemented as part of a software program being executed on a computer, such as thecomputer102, theserver152 running a kernel, etc. In some embodiments, themethod400 may be implemented by thecomputational application140 being executed on thecomputer102, a kernel of thecomputational application140 being executed on theserver152, etc. In some embodiments, themethod400 may be implemented, at least partially, by the cloud-based developmentfront end144, the cloud-baseddevelopment system188, or a combination of the two.

Atblock404, programmer input in a programming language is received, the programmer input including i) a first function corresponding to making electronic objects accessible on a network, and ii) a parameter indicating an electronic object corresponding to a second function for analyzing electronic messages such as emails. For example, in an embodiment, a programmer enters the programming input via a user interface of or coupled to thecomputer102. In some embodiments, the programmer input may be entered into a notebook, workspace, etc., of thecomputational application140. In some embodiments, the first function may be a built-in function of the programming language. In an embodiment, the first function is the CloudDeploy function. The second function may be a function for analyzing electronic messages such as described above. In some embodiments, the second function includes a keyword such as MailReceiverFunction, or another suitable keyword, corresponding to a built-in function of a programming language for facilitating analysis of electronic messages.

In various embodiments, the electronic object indicated by the parameter may include one or more of data, further programming input in the programming language, etc.

In various embodiments, the programmer input includes one or more other parameter regarding how the object is to be deployed. For example, in various embodiments, the programmer input may include a further parameter indicating that the electronic object is to be evaluated by the server in response to email corresponding to the object.

As another example, in various embodiments, the programmer input may include a further parameter indicating permission information for access to the object after deployment.

As another example, in various embodiments, the programmer input may include a further parameter indicating a location at which the object is to be deployed, such a handle to an already deployed object, a URI, etc.

Atblock408, the programmer input is evaluated to cause the electronic object to be stored on a server and made accessible via a network coupled to the server. For example, in an embodiment, the programmer input is evaluated at thecomputer102 by thecomputational application140. As another example, in an embodiment, block408 includes, additionally or alternatively, evaluating the programmer input at theserver152 by a server-side portion (e.g., a kernel, etc.) of thecomputational application140.

In an embodiment, block408 includes thecomputer102, in response to evaluating the programmer input, sending a message to theserver152 via thenetwork150, the message requesting theserver152 to deploy the object in thecloud storage180 and to make the object accessible via the network150 (or another network coupled to the cloud storage180). In various embodiments and/or scenarios, the message includes the object or an indicator of where the object may be obtained, such as a pointer to where the object is stored in a memory (e.g., thememory108, thecloud storage180, etc.), a URI corresponding to the object, etc.

In some embodiments and/or scenarios, the message may contain one or more further parameters such as a further parameter indicating how the electronic object is to be evaluated by the server, a further parameter indicating to the server that the object is to be evaluated by the server in response to emails corresponding to the object, etc. As another example, in some embodiments, the message may contain a further parameter indicating permission information for access to the object after deployment.

In an embodiment in which the programmer input is evaluated at theserver152, block408 may include theserver152 extracting from the programmer input the object or an indicator of where the object may be obtained, such as a pointer to where the object is stored in a memory (e.g., thememory108, thecloud storage180, etc.), a URI corresponding to the object, etc. In an embodiment in which the programmer input is evaluated at theserver152, block408 may include theserver152 extracting from the programmer input further parameters such as described above.

In response to evaluating the programmer input and/or receiving the message discussed above, theserver152 may store the object in thecloud storage180 and make the object accessible via the network150 (or another network), in various embodiments. In an embodiment, theserver152 may determine where in thecloud storage180 the object is to be deployed. If provided in the message and/or the programmer input, theserver152 may utilize a parameter included in the programmer input that indicates a location at which the object is to be deployed, in an embodiment.

If provided in the message and/or the programmer input, theserver152 may utilize one or more parameters specifying how the object is to be deployed such as how often, when, etc., the object is to be evaluated when deployed, permission information for access to the object, etc., and may theserver152 may deploy the object according to the parameters.

Atblock412, in response to evaluating the programmer input, a handle to the deployed electronic object is received, the handle to enable accessing the electronic object via the network. In various embodiments, the handle may comprise a pointer, a web page address, a Hypertext Transfer Protocol (HTTP) address, a URI, a universal resource locator (URL), etc. In an embodiment, the handle comprises a messaging address (e.g., an email address) corresponding to invoking the electronic object. For example, in an embodiment, the electronic object, after being deployed, can then be invoked by sending an electronic message to the address.

In an embodiment, theserver152 may send the handle to thecomputer102 via thenetwork150. In an embodiment, theserver152 may include the handle in a subsequent message that is responsive to a message sent from thecomputer102 to theserver152 that requested theserver152 to deploy the object in thecloud storage180 and to make the object accessible via the network150 (or another network).

In some embodiments, block412 is omitted. For example, in some embodiments, the server may publish the handle, URI, URL, messaging address, email address, etc., to a repository (e.g., in thecloud storage180 or another suitable location) where the handle, URI, URL, messaging address, email address, etc., can be retrieved.

Instant API

Referring again toFIG. 1, thesystem100 may facilitate efficient generation of application programming interfaces (APIs), and deployment of APIs to the web, according to some embodiments. For example, the cloud-baseddevelopment system188 and/or the cloud-based developmentfront end144 may include an API generation module that enables efficient and flexible generation of APIs. Embodiments of an API generation module and techniques for generating APIs are discussed below. In some embodiments, such modules and techniques may be implemented by thesystem100 ofFIG. 1. In other embodiments, such modules and techniques may be implemented by systems different than the system ofFIG. 1.

For example,FIG. 5 is a diagram of anexample system2100 for creating APIs, according to an embodiment. As described in more detail below, thesystem2100 enables efficient and flexible generation of APIs, according to some embodiments.

In an embodiment, thesystem2100 includes a computer similarly structured to thecomputer102 ofFIG. 1. For purposes of brevity, like-numbered components are not described in detail.

In an embodiment, thememory108 may store an API generation module2150 that facilitates generation of APIs, as will be described in more detail below. In an embodiment, the API generation module2150 comprises software instructions that, when executed by theprocessor104, causes the processor to evaluate programming input from a programmer to generate an API such that the API subsequently can be utilized to perform a processing action. For example, as will be described in more detail below, the generated API can be utilized by a software program running on thecomputer102, thecomputational application140 running on the computer102 (not shown inFIG. 5), etc., according to various embodiments. As another example, as will be described in more detail below, the generated API can be deployed to cloud storage and made network accessible (e.g., using CloudDeploy or another suitable mechanism), and a software program running on thecomputer102 or another suitable computer, thecomputational application140 running on the computer102 (not shown inFIG. 5) or another suitable computer, a cloud-based program running on one or more servers, etc., may utilize the API via a network, according to various embodiments.

In some embodiments, generatedAPIs2154 are stored in thememory108.

In some embodiments, the API generation module2150 is a component of the cloud-basedfront end144. In some embodiments, the API generation module2150 is a component of a compiler, i.e., a computer program that transforms source code written in a programming language into another computer language, typically to create an executable program. In some embodiments, the API generation module2150 is a component of an interpreter, i.e., a computer program that directly executes, i.e. performs, instructions written in a programming or scripting language (referred to herein for brevity as a “programming language”), without first compiling the instructions into a machine language program. Thus, in some embodiments, the programming input evaluated by the API generation module2150 includes software instructions written in a programming language.

In some embodiments, the API generation module2150 is a component of a software application such as a computational application140 (FIG. 1). For example, the API generation module2150 may be a component of the MATHEMATICA® computational software program developed by Wolfram Research, Inc., according to a specific embodiment.

In an embodiment, an APIFunction function enables a programmer to create an API. The programming language defines the keyword “APIFunction” as indicating a particular built in function as described below, according to various embodiments. In various embodiments, one or more of thecomputational application140, the cloud-based developmentfront end144, the cloud-baseddevelopment system module188, and/or theAPI generation module2100 are configured to recognize the keyword “APIFunction” as indicating the particular built in function as described below.

FIG. 6 is a diagram of anotherexample system2200 for generating APIs, according to another embodiment. As described in more detail below, thesystem2200 enables efficient and flexible generation of APIs, according to some embodiments. In an embodiment, thesystem2200 is similarly structured to thesystem100 ofFIG. 1. For purposes of brevity, like-numbered components are not described in detail.

In an embodiment, thememory158 may store some or all of theAPI generation module2100 discussed above. For example, in an embodiment, theAPI generation module2100 is implemented as a client-server system, and thememory158 stores a server portion of theAPI generation module2100, whereas thememory108 of thecomputer102 stores a client portion of the API generation module2150. In an embodiment, a programmer uses thecomputer102 to provide programming input to theserver152 via thenetwork150. Theserver152 then generates an API, and the API is stored in a memory. For example, in an embodiment, the API is stored in thememory158 and/or thecloud storage180. In some embodiments, thecloud storage180 is omitted. In another embodiment, the API is transmitted to thecomputer102, via thenetwork150, and is stored in thememory108. In another embodiment, the API is stored in a memory of another server system (e.g., a web server (not shown)) so that the API is accessible via the Internet, for example.

FIG. 7 is a flow diagram of anexample method2300 for generating an API, according to an embodiment. Themethod2300 may be implemented by thecomputer102 ofFIG. 5 and/or thesystem2200 ofFIG. 6, in some embodiments, and themethod2300 is discussed with reference toFIGS. 5 and 6 for explanatory purposes. In other embodiments, however, themethod2300 is implemented by a suitable computer or a suitable system (e.g., multiple computers) other than thecomputer102 and/or the system2300 (e.g., by thesystem100 ofFIG. 1 or another suitable system).

Atblock2304, programmer input in a programming language is received at one or more computers. For example, programmer input is received, via one ormore input devices112, at thecomputer102. In some embodiments, thecomputer102 transmits the programmer input to theserver152 via thenetwork150, and thus the programmer input is received at theserver152. The programmer input includes i) first specification data corresponding to input parameters for an API to be generated, and ii) second specification data that indicates a function to performed, the function for analyzing electronic messages such as emails.

FIG. 8A illustrates an example ofprogrammer input2400 such as programmer input that can be received atblock2304, according to an illustrative embodiment. Theprogrammer input2400 includes built-infunction2404 of a programming language, i.e. APIFunction[ ], that a programmer may utilize to efficiently create an API. The programming language defines the keyword “APIFunction” as indicating a particular built in function as described below, according to various embodiments. In various embodiments, one or more of thecomputational application140, the cloud-based developmentfront end144, and the cloud-baseddevelopment system module188 are configured to recognize the keyword “APIFunction” as indicating the particular built in function as described below.

The built-infunction2404 includes two arguments:first specification data2408 andsecond specification data2412, where thefirst specification data2408 specifies an input parameter to an API to be generated, and the second specification data that specifies a function to be applied to input parameter. In some embodiments, the first specification data also may specify, for each of at least some input parameters, a type of the parameter.

Thesecond specification data2412 defines a function to be applied to emails. Theprogrammer input2412 corresponds to a function that i) searches a body of a first email for the string “table”, and ii) if the string “table” is found within the body of the first email, a new second email is sent that a) forwards the first email and b) indicates that the first email mentions a table.

Theprogrammer input200 also includes asecond portion208 that causes the function, defined by thefirst portion204, to be applied to emails in a mailbox file.

Referring again toFIG. 7, atblock2308, the programmer input is evaluated at one or more computers to generate an API that can be passed one or more parameters and that performs the specified function. For example, theAPI generation module2100 may evaluate the programmer input, in an embodiment, to generate the API. In some embodiments, the programmer input is fully evaluated in response to receiving the programmer input. In other embodiments, the programmer is only partially evaluated. For example, in some embodiments, thesecond specification data2412 may not be fully evaluated. For instance, if thespecification data2412 includes software code specifying a function to be performed, the software code may not be evaluated until the API is subsequently invoked or utilized, according to some embodiments. TheAPI generation module2100 may utilize thefirst specification data2408 and the second specification data2412 (and some or all (or none) of other arguments(s) and/or parameters, if provided in the programmer input) to generate the API. The API may include an electronic object having software instructions, where the electronic object is configured such that parameter(s) (specified by the first specification data) can be passed to the electronic object and the electronic object can be invoked to perform the specified function (specified by the second specification data) using the specified parameter(s), in some embodiments. In an embodiment, the API includes software instructions that can be executed by one or more computers to cause the one or more computers to perform the specified function using the specified parameter(s).

In some embodiments, thecomputer102 implementsblock2308. In some embodiments, theserver152 implements block2308. In some embodiments, thecomputer102 and the server system202 together implementblock2308.

Atblock2312, the API generated atblock2308 is stored in a memory. For example, in an embodiment, the API is stored in thememory108. In another embodiment, the API is stored in thememory158. In another embodiment, the API is stored in thecloud storage180. In another embodiment, the electronic form object is stored in some other suitable memory such as a memory of a web server (not shown inFIGS. 5 and 6).

Referring again toFIG. 8A, theprogrammer input2400 includes aname2420 for the API. The name2420 (“func”) can be utilized to access the API, in an embodiment. For example,FIG. 8B illustrates an example ofprogrammer input2450 that is used to access the API and provide a parameter to the API, according to an illustrative embodiment. Theprogrammer input2450 includes the name of the API (“func”) and also data that indicates the parameter, e.g., a file name in which email messages are stored. In response, the API is evaluated. In the illustrative embodiment ofFIG. 8B, theprogrammer input2450 may be entered into a file, a notebook, a web page, etc. In other embodiments other suitable programmer input is received in another suitable manner, such as via a spreadsheet, etc.

In some embodiments, the API may be created by theAPI generation module2100 and/or the API generation module2150 then made available for use by one or more of another application (e.g., different than the computational application140), another program, and/or a different computer from the computer(s) on which the API was generated.

For example, in some embodiments, the generated API may be made accessible via network-accessible storage, such as thecloud storage180. For example, the generated API may be made accessible via a URL, a URI, etc., or some other suitable mechanism. In some embodiments, the CloudDeploy function may be utilized to deploy an API to network-accessible storage such as thecloud storage180.

In some embodiments, techniques described in U.S. patent application Ser. No. 14/549,541, may be utilized for generation of APIs, accessing APIs, etc.

FIG. 9A is an illustrative example in which a programmer utilizes the CloudDeploy function and the APIFunction to generate an API and deploy the generated API to network-accessible storage, such as thecloud storage180. In the example ofFIG. 9A, the API to be deployed utilizes a built-in function of MATHEMATICA®, GeoGraphics. The GeoGraphics function generates a 2-dimensional (2D) geographic image.

Programmer input

2500 includes theAPIFunction2504,first specification data2508, and second specification data2512, where thefirst specification data2508 specifies an input parameter to an API to be generated and a type of the parameter, and the second specification data2512 that specifies a function to be applied to input parameter. For instance, thespecification data2508 specifies an input parameter “name” of a type “Country”, and the second specification data2512 specifies that the GeoGraphics function is to be applied to the “country” input parameter to draw a polygon of the country indicated by the input parameter, and to generate a result in a Portable Network Graphics (PNG) format.

Additionally, theprogrammer input2500 includes theCloudDeploy function2540. Evaluation of the CloudDeploy function inFIG. 9A returns a handle corresponding to deployment of the expression. The handle includes a URL that enables access to the API.FIG. 9B illustrates a web page that a user sees when entering, in a web browser, a URL corresponding to the handle, and appending a parameter input to the URL (e.g., “?name=Italy”). In particular, the web page includes 2D geographic polygon drawing of Italy. In an embodiment, a server, such as theserver152, receives the URL with the appended parameter information from a requesting computer, uses the URL to locate the API in thecloud storage180, evaluates the API using the appended parameter information to generate a result, and the returns to the requesting computer the result in a web page.

Thus, in various embodiments, the cloud-baseddevelopment system188 may be configured to perform one or more of, or various suitable combinations of two or more of: create an API, deploy the API, give and/or associate the API a name, associate the API with one or more methods, actions, and/or functions to be performed (e.g., methods, actions, and/or functions corresponding to the processing of electronic messages such as emails), and associate the API with one or more various parameters, store the API in thecloud storage180, create a mapping paradigm to map portions of a URL or URI to the methods, actions, and/or functions and/or to the parameter(s) of the methods, actions, and/or functions, such that the methods, actions, and/or functions can be called from a browser, by a website, by a mobile application, by a form, etc., merely by sending a URL complying with the API. In embodiments, the cloud-baseddevelopment system188 may generate documentation for the API, describing the implementation of the API, the mapping of the methods, actions, and/or functions to the URL, the format of the data returned by the API, etc.

In some embodiments, the cloud-baseddevelopment system188 provides an option to allow a user to interact with the cloud-baseddevelopment system188 to edit or revise the mapping, the API name, and other aspects of the API creation. For example, in embodiments, the instant API module may suggest additional functions or methods to add to the API. The instant API module may also facilitate the use of data, variables, and/or parameters stored in network accessible storage (i.e., on the cloud servers), and/or data stored at a location specified by a URL. For example, the cloud-baseddevelopment system188 may provide various user interface mechanisms to permit a user to facilitate editing/revisions such as described above.

In some embodiments, the APIs can be configured to accept natural language (i.e., free-form) inputs. As an illustrative example, an API may be configured to accept a date input specified as “first Monday before Christmas.” The API and/or the cloud-baseddevelopment system188 may include a module configured to convert such natural-language input to a canonical form.

In an embodiment, the programming language utilized by the computational application140 (e.g., the Wolfram Language™ utilized by MATHEMATICA®) and associated with the cloud-baseddevelopment system188 permits representation of at least some objects (e.g., APIs) symbolically in the cloud.

In some embodiments, thecomputational application140, the cloud-basedfront end144, and/or the cloud-baseddevelopment system188 utilizes a computable document format (CDF) that allows exchange of components with interactive features between desktop and mobile platforms and the cloud-based development system188 (for example). An author can generate a CDF document on desktop software (e.g., MATHEMATICA®), and deploy it to thecloud storage180 using native function calls. From the cloud platform it can be served according to access control information to web visitors (e.g., publically, privately, or only to those who have a link to the document). The author can then access the deployed CDF (e.g., via the cloud-based development system188) to make modifications. A revised version is then made available to all platforms automatically.

Invoking Executable Objects By Electronic Messages Such as Emails

Referring again toFIG. 1, after an executable object has been deployed to thecloud storage database180 using techniques such as described above (or using other suitable techniques), the executable object may be invoked via email, according to some embodiments.

FIG. 10 illustratesexample programmer input3000 for evaluating emails, according to an embodiment. Theprogrammer input3000 is similar to theprogrammer input300 ofFIG. 3A, and includes afirst portion3004 that defines a function func to be applied to emails. Theprogrammer input3004 corresponds to a function that i) searches a body of a first email for the string “table”, and ii) if the string “table” is found within the body of the first email, the information from the email (sender, prices extracted from the email, body of the message, attachments) is appended to data structure called “TablesForSale” having the following elements: “Seller”, “Prices”, “Date”, “Message”, and “Pictures”.

Theprogrammer input3000 also includes asecond portion3008 that causes the function, defined by thefirst portion3004, to be deployed as a cloud object that applies the function to emails sent to the cloud object. Emails sent to the cloud object will thus be evaluated and information extracted from emails with the word “table” will be appended to the data structure TablesForSale in a manner similar to that described with reference toFIGS. 3A and 3B.

FIG. 10 also illustrates anoutput3012 generated by one or more of thecomputational application140, the cloud-based developmentfront end144, and/or the cloud-baseddevelopment system module188 in response to evaluation of theprogrammer input3008. Theoutput3012 includes anemail address3016 that can be utilized to send emails to the deployed cloud object. In an embodiment, theemail address3016 includes aunique ID3020 associated with the deployed cloud object.

FIG. 11 illustratesexample programmer input3100 for evaluating emails, according to an embodiment. Theprogrammer input3100 includes afirst portion3004 that defines a function func to be applied to emails. Theprogrammer input3104 corresponds to a function that, upon receiving a first email, sends a second email that includes an indication of sender of the first email and the subject line of the first email.

Theprogrammer input3100 also includes asecond portion3108 that causes the function, defined by thefirst portion3104, to be deployed as a cloud object that applies the function to first emails sent to the cloud object. First emails sent to the cloud object will thus be evaluated and corresponding second emails will be sent.

FIG. 11 also illustrates anoutput3112 generated by one or more of thecomputational application140, the cloud-based developmentfront end144, and/or the cloud-baseddevelopment system module188 in response to evaluation of theprogrammer input3108. Theoutput3112 includes anemail address3116 that can be utilized to send emails to the deployed cloud object. In an embodiment, theemail address3116 includes aunique ID3120 associated with the deployed cloud object.

In the examples ofFIGS. 10 and 11, the email addresses3016 and3116 include a base email address (e.g., receiver+ . . . @wolframcloud.com) generally corresponding to invoking an executable object, and an

extension

3020,3120 to the base email address that indicates the particular executable object that is to be invoked, according to an illustrative embodiment.

FIG. 12 is a flow diagram of anexample method3800 for invoking an executable object in response to an email, according to an embodiment. Themethod3800 may be implemented in thesystem100 ofFIG. 1, in some embodiments, and themethod3800 is discussed with reference toFIG. 1 merely for explanatory purposes. In other embodiments, themethod3800 is implemented in another suitable system. Similarly, in some embodiments, thesystem100 does not implement themethod3800, but rather implements another suitable method for invoking executable objects in response to emails.

Atblock3804, an email is received, where the email includes an indicator of an executable object to be invoked. For example, in some embodiments, theemail server194 may receive an email message with a specific “to” address corresponding to a deployed executable object. As merely an illustrative example, theemail server194 may recognize a base email address as generally corresponding to invoking an executable object, and an extension to the base email address as indicating the particular executable object that is to be invoked, according to an illustrative embodiment. For example, the email address may be a base text string+a short URL corresponding to the deployed executable object, according to an embodiment.

As another example, theemail server194 may receive an email message with the unique ID in the subject line of the email, according to an embodiment. As another example, theemail server194 may receive an email message with the unique ID in the content of the email, according to an embodiment.

Atblock3808, the corresponding executable object is invoked using the indicator in email received atblock3804. For example, in some embodiments, theemail server194 may be configured to determine an extension to a base email address as indicating the particular executable object that is to be invoked, and then invoke the executable object corresponding to the extension. As another example, in some embodiments, theemail server194 may be configured to determine a subject of the email as including an indicator of the particular executable object that is to be invoked, and then invoke the executable object corresponding to the indicator. For example, the subject of the email may include a unique ID corresponding to the executable object, and theemail server194 may be configured to analyze the subject of the email to identify the unique ID, in an embodiment. As yet another example, in some embodiments, theemail server194 may be configured to determine body of the email as including an indicator of the particular executable object that is to be invoked, and then invoke the executable object corresponding to the indicator. For example, the body of the email may include a unique ID flagged with a reserved combination of alphanumeric characters, a keyword, etc., and theemail server194 may be configured to analyze the subject of the email to identify the unique ID, according to various embodiments.

In some embodiments, invoking the executable object may include utilizing the unique ID. For example, in some embodiments, the unique ID may correspond to a URL (e.g., short, long, etc.), and the email (or a portion of the email (e.g., one or more of the body of the email, a sender email address, a reply to address, etc.) may be provided to the URL using the Hypertext Transfer Protocol (HTTP). In various embodiments, theemail server194 may invoke and pass email information to the executable object using a technique such as the Simple Object Access Protocol (SOAP), the SOAP with Attachments (SwA) protocol, the JavaScript Object Notation for Remote Procedure Call (JSON-RPC) protocol, the Extensible Markup Language for Remote Procedure Call (XML-RPC) protocol, etc., or another suitable technique.

Upon being invoked, the executable object may process information from the email message. For example, a programmer may design the executable object to perform sophisticated email filtering and to forward emails to selected different email addresses based on the email filter processing, in an illustrative embodiment. As another example, a programmer may design the executable object to perform sophisticated spam filtering and to forward emails to selected different email addresses based on the email filter processing, in an illustrative embodiment. As another example, a programmer may design the executable object to perform sophisticated spam filter training, in an illustrative embodiment. As another example, a programmer may design the executable object to gather statistics or metrics on received emails, in an illustrative embodiment. As another example, a user may utilize the system for information gathering and processing, in an embodiment. For instance, a programmer may design the executable object to process data provided in emails and to store processing results, in an illustrative embodiment. In some embodiments, this may provide a convenient manner for gathering, receiving, and/or processing information in lieu of web-based forms, for example. As a specific example, programmer may design the executable object to perform image processing operations on images provided in (or attached to) emails and to store the image processing results, in an illustrative embodiment. In some embodiments, the system may utilize techniques described in U.S. patent application Ser. No. 14/872,129 for storing processing results, retrieving already stored data, etc. U.S. patent application Ser. No. 14/872,129, filed on Sep. 20, 2015, entitled “Cloud Storage Methods and Systems,” is hereby incorporated by reference.

In some embodiments, thesystem100 and/or the executable object may be designed to cause the email server194 (or another email server, not shown) to send a reply email and/or acknowledgment email in response to theemail server194 receiving an email message, in response to the executable object being invoked, etc. For example, the executable object may process the email to determine the “from” or “reply to” address in the email message, and then instruct the email server194 (or another email server, not shown) to send another email message to the “from” or “reply to” address. The content of the email message sent to the “from” or “reply to” address by the email server194 (or another email server, not shown) may be specified by the executable object, in some embodiments. Alternatively, the content of the email message sent to the “from” or “reply to” address by the email server194 (or another email server, not shown) may be a default message of thesystem100, in some embodiments.

A variety of different levels and types of developer tools may be included in thesystem100 to assist the user in creating executable objects and/or configuring executable objects for invocation by an email message. For example, a GUI may assist the user, provide default configurations, etc., for example, as described elsewhere herein with respect to thesystem100.

In various embodiments, functions describe herein can be modified, omitted, combined with other functions, etc. For example, CloudDeploy and MailReceiverFunction are combined into single function, in an embodiment.

In another embodiment, a method includes: receiving, at one or more computers, programmer input in a programming language, the programmer input i) specifying a function to be performed by one or more computers, and ii) specifying that the function is to be applied by one or more computers to one or more electronic messages. The method further comprises at least one of: i) applying, at one or more computers, the function to one or more electronic messages indicated by the programmer input, and ii) generating, with one or more computers, an executable electronic object corresponding to the function, wherein the executable electronic object is generated such that the executable electronic object is configured to, when invoked, cause one or more computers to apply the function to one or more electronic messages.

In other embodiments, the method further includes one of, or any suitable combination of two or more of, the following features.

The method further includes: receiving, at one or more computers an electronic message with a destination address corresponding to the executable electronic object; and in response to receiving the electronic message with the destination address corresponding to the executable electronic object, invoking, with one or more computers, the executable electronic object so that the function is applied to the received electronic message.

The method further includes: receiving, at one or more computers, an electronic message from a server (e.g., an email server) via a network; and in response to receiving the electronic message invoking, with one or more computers, the executable electronic object so that the function is applied to the received electronic message.

The electronic message is an email message; and the destination address is an email address.

The programmer input includes a keyword, defined by the programming language, that specifies that the function is to be applied by one or more computers to one or more electronic messages.

The programmer input further includes a parameter that indicates one or more electronic messages to which the function is to be applied; and the method further comprises: applying, at one or more computers, the function to the one or more electronic messages indicated by the parameter.

In other embodiments, a system comprises: one or more processors; and one or more memory devices coupled to the one or more processors. The one or more memory devices store machine readable instructions that, when executed by the one or more processors, cause the one or more processors to perform one or more of the methods described above.

In still other embodiments, a tangible, non-transitory computer readable medium, or media, stores machine readable instruction that, when executed by the one or more processors, cause the one or more processors to perform one or more of the methods described above.

Unless specifically stated otherwise, discussions herein using words such as “processing,” “computing,” “calculating,” “determining,” “presenting,” “displaying,” or the like may refer to actions or processes of a machine (e.g., a computer) that manipulates or transforms data represented as physical (e.g., electronic, magnetic, or optical) quantities within one or more memories (e.g., volatile memory, non-volatile memory, or a combination thereof), registers, or other machine components that receive, store, transmit, or display information.

As used herein any reference to “one embodiment” or “an embodiment” means that a particular element, feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment. The appearances of the phrase “in one embodiment” or the phrase “in an embodiment” in various places in the specification are not necessarily all referring to the same embodiment.

Some embodiments may be described using the expression “coupled” and “connected” along with their derivatives. For example, some embodiments may be described using the term “coupled” to indicate that two or more elements are in direct physical or electrical contact. The term “coupled,” however, may also mean that two or more elements are not in direct contact with each other, but yet still co-operate or interact with each other. The embodiments are not limited in this context.

As used herein, the terms “comprises,” “comprising,” “includes,” “including,” “has,” “having” or any other variation thereof, are intended to cover a non-exclusive inclusion. For example, a process, method, article, or apparatus that comprises a list of elements is not necessarily limited to only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Further, unless expressly stated to the contrary, “or” refers to an inclusive or and not to an exclusive or. For example, a condition A or B is satisfied by any one of the following: A is true (or present) and B is false (or not present), A is false (or not present) and B is true (or present), and both A and B are true (or present).

In addition, use of the “a” or “an” are employed to describe elements and components of the embodiments herein. This is done merely for convenience and to give a general sense of the description. This description should be read to include one or at least one and the singular also includes the plural unless it is obvious that it is meant otherwise.

At least some of the various blocks, operations, and techniques described above may be implemented utilizing hardware, a processor executing firmware instructions, a processor executing software instructions, or any combination thereof. When implemented in hardware, the hardware may comprise one or more of discrete components, an integrated circuit, an ASIC, a programmable logic device, etc. When implemented utilizing a processor executing software or firmware instructions, the software or firmware instructions may be stored in any tangible, non-transitory computer readable medium, or media, such as a magnetic disk, an optical disk, a tape drive, a RAM, a ROM, a flash memory, a memory of a processor, etc. Likewise, the software or firmware instructions may be delivered to a user or a system via any known or desired delivery method including, for example, on a tangible, non-transitory computer readable medium or media, or via communication media. The software or firmware instructions may include machine readable instructions that, when executed by the processor, cause the processor to perform various acts.

Upon reading this disclosure, those of skill in the art will appreciate still additional alternative structural and functional designs for a system and a process for identifying terminal road segments through the disclosed principles herein. Thus, while particular embodiments and applications have been illustrated and described, it is to be understood that the disclosed embodiments are not limited to the precise construction and components disclosed herein. Various modifications, changes and variations, which will be apparent to those skilled in the art, may be made in the arrangement, operation and details of the method and apparatus disclosed herein without departing from the spirit and scope defined in the appended claims.