U.S. patent application number 14/618213 was filed with the patent office on 2015-06-25 for object modeling for exploring large data sets.
The applicant listed for this patent is Palantir Technologies, Inc.. Invention is credited to Andrew Aymeloglu, Brandon Burr, Eric Poirier, Kevin Simler, Garry Tan.
Application Number | 20150178743 14/618213 |
Document ID | / |
Family ID | 42005782 |
Filed Date | 2015-06-25 |
United States Patent
Application |
20150178743 |
Kind Code |
A1 |
Aymeloglu; Andrew ; et
al. |
June 25, 2015 |
OBJECT MODELING FOR EXPLORING LARGE DATA SETS
Abstract
An object model is used to facilitate performing financial
analysis and that includes certain zero-order objects or building
blocks that lend themselves particularly well to doing financial
analysis. The object model comprises a universe of data items,
relationships between the data items, higher-order objects
generated based on one or more data items in the universe,
higher-order objects generated based on other objects, and
auxiliary entities related to the universe of data items.
Inventors: |
Aymeloglu; Andrew; (Palo
Alto, CA) ; Simler; Kevin; (Fremont, CA) ;
Poirier; Eric; (San Carlos, CA) ; Tan; Garry;
(Mountain View, CA) ; Burr; Brandon; (Palo Alto,
CA) |
|
Applicant: |
Name |
City |
State |
Country |
Type |
Palantir Technologies, Inc. |
Palo Alto |
CA |
US |
|
|
Family ID: |
42005782 |
Appl. No.: |
14/618213 |
Filed: |
February 10, 2015 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
12210947 |
Sep 15, 2008 |
|
|
|
14618213 |
|
|
|
|
Current U.S.
Class: |
705/7.29 |
Current CPC
Class: |
G06F 16/2228 20190101;
G06Q 30/0201 20130101; G06Q 40/06 20130101; G06F 16/283 20190101;
G06Q 10/06 20130101 |
International
Class: |
G06Q 30/02 20060101
G06Q030/02; G06F 17/30 20060101 G06F017/30 |
Claims
1. A computer-implemented method, comprising: creating and storing
in computer memory a programmatic object model that facilitates
performing financial analysis and comprising a plurality of
zero-order objects each of which is not decomposable into other
objects; wherein the object model in the computer memory comprises
a universe of data items and relationships between the data items,
and a plurality of higher-order objects the computer generates
based on the zero-order objects; wherein each zero-order object
consists of one of a plurality of time series objects, a plurality
of metric objects, and a plurality of financial instrument objects;
using the computer, generating one or more higher-order objects in
the plurality of higher-order objects using one or more metric
objects in the plurality of metric objects; wherein the method is
performed by one or more computing devices.
2. The method of claim 1, wherein the higher-order objects can be
decomposed into other building blocks, and wherein the higher-order
objects comprise date set objects, index objects, portfolio
objects, strategy objects, instrument group objects, and regression
objects.
3. The method of claim 2, wherein instrument group objects comprise
one or more instruments selected from a universe of instruments
using a filter chain; wherein index objects indicate a collective
value of one or more instruments; wherein regression objects
transform one or more first time series into a predicted time
series and compare the predicted time series with a second time
series; wherein portfolio objects comprise: zero or more time
series each of which represents a particular financial instrument;
a particular date set; and one or more trades that refer to times
represented in the particular date set; wherein strategy objects
comprise a date set that represents a time period and a statement
block that can be executed to determine one or more trades of the
instrument; and wherein date set objects comprise time values that
satisfy one or more selection criteria.
4. The method of claim 2, wherein each of the index objects
comprises an instrument group object, a metric object, and a date
set object.
5. The method of claim 2, wherein each of the instrument group
objects comprises a plurality of filter objects, and wherein each
of the filter objects comprises a set of instrument objects and a
metric object.
6. The method of claim 2, wherein each of the regression objects
comprises a set of time series and a date set object.
7. The method of claim 2, wherein each of the date set objects is
associated with a metric that is configured to receive a time
series as a first input and one or more selection criteria as a
second input and to generate one or more dates in the time series
that are within the specified range.
8. The method of claim 1, further comprising: receiving, at
runtime, user input specifying a name of a custom metric object and
identifying an ordered or concatenated plurality of function tokens
for association with the name of the custom metric object; creating
and storing, in the object model, a custom metric object based on
the name and the tokens.
9. A non-transitory machine-readable storage medium comprising one
or more program instructions recorded thereon, which instructions,
when executed by one or more processors, cause the one or more
processors to perform the steps of: creating and storing in
computer memory a programmatic object model that facilitates
performing financial analysis and comprising a plurality of
zero-order objects each of which is not decomposable into other
objects; wherein the object model in the computer memory comprises
a universe of data items and relationships between the data items,
and a plurality of higher-order objects the one or more processors
generate based on the zero-order objects; wherein each zero-order
object consists of one of a plurality of time series objects, a
plurality of metric objects, and a plurality of financial
instrument objects; and using the one or more processors,
generating one or more higher-order objects in the plurality of
higher-order objects using one or more metric objects in the
plurality of metric objects.
10. The medium of claim 9, wherein the higher-order objects can be
decomposed into other building blocks, and wherein the complex
objects comprise date set, index, portfolio, strategy, instrument
group, and regression objects.
11. The medium of claim 10, wherein instrument group objects
comprise one or more instruments selected from a universe of
instruments using a filter chain; wherein index objects indicate a
collective value of one or more instruments; wherein regression
objects transform one or more first time series into a predicted
time series and compare the predicted time series with a second
time series; wherein portfolio objects comprise: zero or more time
series each of which represents an instrument; a particular date
set; and one or more trades that refer to times represented in the
particular date set; wherein strategy objects comprise a date set
that represents a time period and a statement block that can be
executed to determine one or more trades of the instrument; wherein
date set objects comprise time values that satisfy one or more
selection criteria.
12. The medium of claim 10, wherein each of the index objects
comprises an instrument group object, a metric object, and a date
set object.
13. The medium of claim 10, wherein each of the instrument group
objects comprises a plurality of filter objects, and wherein each
of the filter objects comprises a set of instrument objects and a
metric object.
14. The medium of claim 9, wherein the one or more program
instructions further comprise instructions which, when executed by
one or more processors, cause the one or more processors to
perform: receiving, at runtime, user input specifying a name of a
custom metric object and identifying an ordered or concatenated
plurality of function tokens for association with the name of the
custom metric object; creating and storing, in the object model, a
custom metric object based on the name and the tokens.
15. An application server comprising: a network interface that is
coupled to a data network for receiving one or more packet flows
therefrom; a processor; and one or more stored program instructions
which, when executed by the processor, cause the processor to carry
out the steps of: creating and storing in computer memory a
programmatic object model that facilitates performing financial
analysis and comprising a plurality of zero-order objects each of
which is not decomposable into other objects; wherein the object
model in the computer memory comprises a universe of data items and
relationships between the data items, and a plurality of
higher-order objects that the processor generates based on the
zero-order objects; wherein each zero-order object consists of one
of a plurality of time series objects, a plurality of metric
objects, and a plurality of financial instrument objects; using the
processor, generating one or more higher-order objects in the
plurality of higher-order objects using one or more metric objects
in the plurality of metric objects.
16. The application server of claim 15, wherein the higher-order
objects can be decomposed into other building blocks, and wherein
the higher-order objects comprise date set, index, portfolio,
strategy, instrument group, and regression objects.
17. The application server of claim 16, wherein instrument group
objects comprise one or more instruments selected from a universe
of instruments using a filter chain; wherein index objects indicate
a collective value of one or more instruments; wherein regression
objects transform one or more first time series into a predicted
time series and compare the predicted time series with a second
time series; wherein portfolio objects comprise: zero or more time
series each of which represents an instrument; a particular date
set; and one or more trades that refer to times represented in the
particular date set; wherein strategy objects comprise a date set
that represents a time period and a statement block that can be
executed to determine one or more trades of the instrument; wherein
date set objects comprise time values that satisfy one or more
selection criteria.
18. The application server of claim 16, wherein each of the index
objects comprises an instrument group object, a metric object, and
a date set object.
19. The application server of claim 16, wherein each of the
instrument group objects comprises a plurality of filter objects,
and wherein each of the filter objects comprises a set of
instrument objects and a metric object.
20. The application server of claim 15, wherein the one or more
program instructions further comprise instructions which, when
executed by one or more processors, cause the one or more
processors to perform: receiving, at runtime, user input specifying
a name of a custom metric object and identifying an ordered or
concatenated plurality of function tokens for association with the
name of the custom metric object; creating and storing, in the
object model, a custom metric object based on the name and the
tokens.
Description
BENEFIT CLAIM
[0001] This application claims benefit under 35 U.S.C. .sctn.120 as
a Continuation of U.S. application Ser. No. 12/210,947, filed Sep.
15, 2008, the entire contents of which are hereby incorporated by
reference for all purposes as if fully set forth herein. The
applicant(s) hereby rescind any disclaimer of claim scope in the
parent application(s) or the prosecution history thereof and advise
the USPTO that the claims in this application may be broader than
any claim in the parent application(s).
FIELD OF THE DISCLOSURE
[0002] The present disclosure generally relates to techniques for
exploring large data sets, for example, as related to market
instruments.
BACKGROUND
[0003] The approaches described in this section are approaches that
could be pursued, but not necessarily approaches that have been
previously conceived or pursued. Therefore, unless otherwise
indicated, it should not be assumed that any of the approaches
described in this section qualify as prior art merely by virtue of
their inclusion in this section.
[0004] Data processing systems can be programmed to facilitate
analysis of a universe of data items. A universe of data items
refers to a large collection of data items. An example of such a
universe may be a large collection of market instruments. In many
instances, the amount of raw data about data items can be massive
and dynamically increasing all the time. Under some approaches, an
analyst relies on empirical knowledge and cumbersome spreadsheets
to analyze markets and instruments. Under some other approaches,
markets and instruments are modeled as multi-variable stochastic,
predictive systems. In all these approaches, however, what has been
captured is often over-simplified and relatively static. These
approaches cannot keep up with new variable and new trends
appearing in the markets, and therefore can hardly yield reliable
insights for future performance of the markets and instruments.
These shortcomings are made worse, as these approaches typically
provide little support for a user to flexibly model the markets, to
promptly react to new trends, and to timely test new
hypotheses.
SUMMARY
[0005] The present disclosure is directed to a programmatic object
model that facilitates analysis of universes of data items.
[0006] A first claim of the disclosure is an object model that
facilitates performing financial analysis and that includes certain
zero-order objects or building blocks that lend themselves
particularly well to doing financial analysis. The object model
comprises a universe of data items, relationships between the data
items, higher-order objects generated based on one or more data
items in the universe, higher-order objects generated based on
other objects, and auxiliary entities related to the universe of
data items.
[0007] A second claim is that some of the building blocks are
"zero-order", in that they cannot be decomposed into other building
blocks. Examples of zero-order building blocks are time series,
metrics, and financial instruments. A time series is an object that
represents time-dependent information. A metric building block
represents a type of data transformation; for example, a metric
defines a function that receives an instrument as input and
produces a time series as output. A financial instrument building
block represents any market entity that is traded or otherwise of
interest, such as an equity, a currency, or a bond.
[0008] A third claim is that some of the building blocks can be
decomposed into other building blocks. Examples include a date set,
index, portfolio, strategy, instrument group, and regression. For
example, a date set comprises time values that satisfy one or more
selection criteria; an instrument group comprises one or more
instruments selected from a universe of instruments using a filter
chain; an index indicates a collective value of one or more
instruments; a regression transforms one or more first time series
into a predicted time series and compares the predicted time series
with a second time series; a portfolio comprises zero or more time
series each of which represents an instrument, a particular date
set, and one or more trades that refer to times represented in the
particular date set; a strategy comprises a date set that
represents a time period and a statement block that can be executed
to determines one or more trades of the instrument.
[0009] Additional claims of the disclosure relate to how the
foregoing higher-order building blocks can be decomposed into the
zero-order building blocks. For example, an index comprises an
instrument group and a metric and a date set; an instrument group
comprises filters; and a filter can be a set of instruments and a
metric.
[0010] In embodiments where data items are instruments (in equity,
currency and bonds), zero-order objects may refer to instruments,
economic indexes, time series and meta data associated with
instruments, and other information that are cataloged and stored in
a database for the purpose of being analyzed by the data analysis
system.
[0011] Other embodiments may comprise a system and one or more
machine-readable storage media operable to provide the foregoing
graphical user interface and/or to perform or cause the performance
of the foregoing computer-implemented methods.
BRIEF DESCRIPTION OF THE DRAWINGS
[0012] FIG. 1 illustrates an example data analysis system for
exploring a universe of data items.
[0013] FIG. 2A illustrates an example graphical user interface
related to a date set.
[0014] FIG. 2B illustrates an example graphical user interface
related to an instrument group.
[0015] FIGS. 2C-1 and 2C-2 illustrate an example graphical user
interface related to a strategy.
[0016] FIGS. 2D-1 and 2D-2 illustrate an example graphical user
interface related to a regression.
[0017] FIG. 2E illustrates an example graphical user interface
related to an index.
[0018] FIG. 2F illustrates an example graphical user interface
related to a custom metric.
[0019] FIG. 2G illustrates an example graphical user interface
related to selecting a custom metric.
[0020] FIG. 2H illustrates an example graphical user interface
related to displaying results involving a custom metric.
[0021] FIG. 3 illustrates an example process flow.
[0022] FIG. 4 illustrates a computer system with which an
embodiment may be implemented.
DESCRIPTION OF EXAMPLE EMBODIMENTS
[0023] In the following description, for the purposes of
explanation, numerous specific details are set forth in order to
provide a thorough understanding of the present invention. It will
be apparent, however, that the present invention may be practiced
without these specific details. In other instances, well-known
structures and devices are shown in block diagram form in order to
avoid unnecessarily obscuring the present invention.
1 GLOSSARY OF TERMS
[0024] In this disclosure the following terms have the following
meanings:
[0025] Data item: a zero-order object that can be described by a
number of properties and/or metrics.
[0026] Higher-order objects: the term "higher-order objects" refers
to objects that can be built directly or indirectly on top of
zero-order objects such as instruments.
[0027] Metric: a type of transformation. The metric performs the
type of transformation specified, e.g., using the instrument as
input, and produces the time series. In some embodiments, the
identifier for the object and the token for the type of
transformation are separated by a suitable delimiter such as a
period.
[0028] Object model: a model that comprises a universe of data
items, relationships between the data items, higher-order objects
generated based on one or more data items in the universe,
higher-order objects generated based on other objects, and
auxiliary entities related to the universe of data items.
[0029] Ontological relationships: structural relationships existing
among zero-order objects (such as economic indexes, instruments,
etc.). The instruments can be classified based on ontological
relationships, thereby forming a hierarchy on which the object
model can be further built. In some embodiments, this hierarchy may
comprise one or more economic indexes, which is not specifically
tied to an instrument.
[0030] Time series: a type of objects which are used in the object
model to represent time-dependent information.
[0031] Universe of data items: a large collection of data items,
typically everything known to a particular system.
[0032] Zero-order objects: leaf nodes in the object model. In
embodiments where data items are instruments (in equity, currency
and bonds), zero-order objects may refer to instruments, economic
indexes, time series and meta data associated with instruments, and
other information that are cataloged and stored in a database for
the purpose of being analyzed by the data analysis system.
2 EXAMPLE DATA ANALYSIS SYSTEM
[0033] FIG. 1 illustrates an example data analysis system for
exploring a universe of data items. Data analysis system 100
comprises application server 102 and one or more clients, such as
client 120.
[0034] In the embodiment illustrated in FIG. 1, client 120, which
may be implemented by one or more first physical computing devices,
is communicatively connected to application server 102, which may
be implemented by one or more second physical computing devices,
over a network. In some embodiments, each such physical computing
device may be implemented as a separate computer system as shown in
FIG. 4. For example, client 120 may be implemented in a computer
system as a set of program instructions recorded on a
machine-readable storage medium, while application server 102 may
be implemented in a different computer system. Client 120 comprises
graphical user interface (GUI) logic 122. GUI logic 122 may be a
set of program instructions which, when executed by one or more
processors of the computer system, are operable to receive user
input and to display a graphical representation of one or more
graphic constructs related to exploring a universe of data items
using the approaches herein. GUI logic 122 may be operable to
receive user input from, and display the graphic constructs to, a
graphical user interface that is provided on display 124 by the
computer system on which client 120 executes.
[0035] In some embodiments, GUI logic 122 is omitted. For example,
in one embodiment, client 120 may comprise an application program
or process that issues one or more function calls or application
programming interface (API) calls to application server 102 to
obtain information resulting from, to provide input to, and to
execute along with application server 102, the processes or one or
more steps thereof as described herein. For example, client 120 may
request and obtain a representation of zero-order objects such as
instruments, higher-order objects such as date sets, indexes,
instrument groups, etc., higher-order objects, and other constructs
as described herein using a programmatic interface, and then the
client may use, process, log, store, or otherwise interact with the
received data according to local logic. Client 120 may also
interact with application server 102 to provide input, definition,
editing instructions, expressions related to one or more objects or
constructs as described herein using a programmatic interface, and
then the application server 102 may use, process, log, store, or
otherwise interact with the received input according to application
server logic.
[0036] Application server 102 may be implemented as a
special-purpose computer system having the logical elements shown
in FIG. 1. In an embodiment, the logical elements may comprise
program instructions recorded on one or more machine-readable
storage media. Alternatively, the logical elements may be
implemented in hardware, firmware, or a combination.
[0037] When executed by one or more processors of the computer
system, logic in application server 102 is operable to explore the
universe of data items according to the techniques described
herein. In one embodiment, application server 102 may be
implemented in a Java Virtual Machine (JVM) that is executing in a
distributed or non-distributed computer system. In other
embodiments, application server 102 may be implemented as a
combination of programming instructions written in any programming
language (e.g. C++ or Visual Basic) and hardware components (e.g.
memory, CPU time) that have been allocated for executing the
program instructions.
[0038] In an embodiment, application server 102 comprises
repository access logic 110 and data exploring logic 104.
Repository access logic 110 may comprise a set of program
instructions which, when executed by one or more processors, are
operable to access and retrieve data from data repository 112. For
example, repository access logic 110 may be a database client or an
Open Database Connectivity (ODBC) client that supports calls to a
database server that manages data repository 112. Data repository
112 may be any type of structured storage for storing data
including, but not limited to, relational or object-oriented
databases, data warehouses, directories, data files, and any other
structured data storage.
[0039] In the embodiment illustrated in FIG. 1, data exploring
logic 104 comprises input receiver 106 and evaluation module 108.
Data exploring logic 104 may be object-oriented logic. As used
herein, the universe of data items can be accessed and/or operated
on by the data exploring logic 104 to create, modify, delete, and
store the data generated or used by data analysis system 100.
[0040] In an embodiment, input receiver 106 is a set of program
instructions which, when executed by one or more processors, are
operable to receive input from a client.
[0041] Evaluation module 108 is a set of program instructions that
implement logic to create, modify, delete and store objects that
are associated with the universe of data items, evaluate these
objects when instructed to do so by data analysis system 100,
provide the evaluation results to a client. Evaluation results of
one or more objects may also be rendered by GUI logic 122 on
display 120.
3 EXAMPLES OF ZERO-ORDER OBJECTS
3.1 Instruments
[0042] An instrument is an object that represents any market traded
financial entity or product of interest, such as a stock (equity),
bond, currency, or fund.
3.2 Metrics
[0043] A metric is a transformation (or function) that receives one
type of data (e.g., an object such as an instrument) and returns
another type (e.g., another object such as a time series). A metric
may perform any form of specified processing, specified
computation, related operations such as database queries, network
communications and data storing. For example, a metric may receive
a particular instrument as input and return a time series of the
particular instrument's volume. A metric may also receive one time
series for an instrument and return the value of the instrument on
a given day. A metric may optionally receive parameters at runtime
that influence the execution of logic implemented in the metric. An
example of a parameter that can be inputted into a metric to
influence the execution of a metric may be a number of days to show
a moving average price for MSFT where the metric calculates the
moving average price.
[0044] Objects that are of a higher order than a zero order can be
built using metrics. The input objects and the output objects can
be zero-order or higher-order in any combination.
[0045] The data changes over time. Therefore, if a metric is
evaluated at two different times, it may produce different outputs.
Alternatively, output objects from one or more of these metrics may
be pre-computed/evaluated and stored/cached beforehand. In some
embodiments, parameters may be provided to a metric to specify
whether a cached object of a metric should be used as input, or
whether the output of a metric should be cached or stored.
3.3 Time Series
[0046] A time series is a programmatic object that represents
time-dependent information in any of several forms, including a
series of discrete dates or a sequence of time-related values.
Where an object model contains a large amount of time-dependent
information, many time series may be created in the process of
evaluating objects in the object model. For example, an instrument
may have a trading history that indicates its values over a period
of time. From this trading history (e.g., raw trading data), one or
more time series may be created to represent time-dependent
information, in any desired resolution (for example, in a time
scale of years, months, weeks, days, hours, minutes, seconds).
[0047] In some embodiments, a time series may comprise a set of
numeric values and a separate set of time values, wherein each
numeric value has a corresponding time value in the set of time
values. Each such numeric value represents a value of a certain
entity at each corresponding time value in the set of time values.
For example, a time series may be used to represent market values
of an instrument. The above-mentioned "value of a certain entity"
may be a particular market value at the closing of a trading day.
In this example, the time series may comprise a set of long or
double values, each of which represents a market value at the
closing of a corresponding day as indicated by a time value in a
separate set of time values. The time series further comprises the
separate set of time values representing the closings of all
corresponding days, for which market values of the instruments are
included in the set of long or double values.
[0048] A time series may also be used to represent values of an
entity for time values that meet certain criteria. For example, a
time series may be used to represent market values for an
instrument when the instrument is traded to higher prices, when the
instrument is traded to lower prices, when the volatility of the
instrument exceeds a certain limit, when the volatility of the
instrument stays below a certain limit, or a derivative of other
time series. Furthermore, the values of an entity are not limited
to market values of an instrument. For example, the values of an
entity, as represented by a time series, may comprise analytical
values of historical volatility of two instruments.
[0049] In some embodiments, a time series associated with an
instrument may be accessed by an expression containing an
identifier (e.g., the identifier "GOOG" to indicate the equity
instrument for Google, Inc.) for another object such as an
instrument and a token (e.g., a textual name such as "HVOL"
representing historical volatility of an instrument) for a type of
transformation. In the present example where the time series is
accessed by the expression "GOOG.HVOL", the metric identified by
the token (e.g., "HVOL") receives the identifier for the instrument
(e.g., "GOOG") as input and transforms raw trading data of the
instrument (i.e., "GOOG") into a time series as an output object.
This time series, for example, may represent time-dependent
information of volatility of the instrument "GOOG" in all recorded
trading days.
[0050] A time series such as described above may be further
transformed along with other parameters into another output
object.
[0051] A time series can not only represent time-dependent
information for zero-order objects such as instruments, but may
also represent time-dependent information for any higher-order
objects in the object model.
[0052] In some embodiments, a time series may be used to represent
time-dependent information that is not related to another object.
For example, a set of time values from a calendar, e.g., all week
days, all work days, all Mondays, or the second days of months, may
be transformed by a metric into a time series. Such a time series
may be viewed as an object per se as it is independent of another
object such as an instrument. In some embodiments, the time series
may be accessed within a global scope, by any other objects,
without naming any other object such as an instrument. In some
embodiments, a time series may comprise a set of time values (e.g.,
all Mondays) without including a separate set of numeric values
representing values of an entity that may be associated with
another object such as an instrument.
[0053] In some embodiments, time series may be pre-computed
(evaluated) and stored/cached.
4 EXAMPLE HIGHER-ORDER OBJECTS
4.1 Date Set
[0054] A date set comprises a set of time values that satisfy one
or more selection criteria. As used herein, the term "time value"
may include date and/or time of day information at various
resolutions, for example, from multiple years to sub-seconds. For
example, a date set may be all trading days when the "GOOG" stock
trades up. A date set may also have an explicit start time value
for the set, for example, Jan. 1, 2006; thus, the date set excludes
all time values that are before the explicit start time value.
Similarly, a date set may also have an explicit end time value;
thus, the date set excludes all time values that are after the
explicit end time value.
[0055] A date set may also take an implicit start time value, where
an explicit start time value is not specified. For example, a date
set that comprises all days when the "GOOG" stock trades up may
have an implicit start time value when the "GOOG" stock was first
publicly traded. Similarly, a date set may also take an implicit
end time value, where an explicit end time value is not specified.
For example, a date set that comprises all days when the "ENE"
stock was available for trades may have an implicit end time value
when the "ENE" stock was terminated from public trading from the
New York Stock Exchange.
[0056] One of several object creation mechanisms may be used to
create higher-order objects such as date sets. One object creation
mechanism is a metric. This metric may take a first input that
specifies a time series. This time series is generally a set of
date/value pairs. The date set metric also may take a second input
that specifies one or more criteria. For example, the one or more
criteria as specified in the second input may specify a range. The
resulting date set will then contain all the dates as indicated by
the time series that are within the specified range.
[0057] Another object creation mechanism to create a higher-order
object such as a date set is to directly use a programming language
such as JAVA. The user may supply programming language code to the
system 100, which may be compiled, interpreted or otherwise
executed by the system 100 to create a date set. Extension
mechanisms such as Java reflection may be used to add code segments
or objects to the system so that the object creation mechanisms can
be dynamically extended.
[0058] Yet another object creation mechanism to create a
higher-order object such as a date set is to interact with a user
interface. For example, tools or widgets may be provided in or
through a graphical user interface and may interact with the user
for the purpose of creating a date set.
[0059] In various embodiments, these and other object creation
mechanisms, or a combination thereof, may be used to create various
higher-order objects.
[0060] A date set may or may not be related to any other object.
For example, as shown in FIG. 2A, a date set may be hard-coded by a
user at client 120. For example, a calendar 202 may be shown at
client 120. Graphic components may be rendered on a graphical user
interface 200 so that the user may select certain time values
(i.e., the user selection provides the second input that specifies
one or more criteria) using calendar 202 (which is the first input
that specifies a time series). With calendar 202 and the user
selection as inputs, an object creation mechanism creates and
outputs the corresponding date set.
[0061] For a generated date set, the user may provide a token in
the form of a string to this date set in a text input box 204.
Subsequently, this date set may be used in combination with other
objects. In an embodiment, any of all the entities that are
involved in specifying, creating and outputting a new date set may
be stored in a machine-readable storage medium. In addition, the
new date set may also be stored or cached in such a medium.
4.2 Index
[0062] An index indicates a collective value of one or more
instruments as a function of time over a set of time values. A
collective value is any type of aggregate value of the one or more
instruments. The collective value may be of a market value type
such as a total monetary value of the one or more instruments
traded at public exchanges, or of an analytical value type such as
a numeric value indicating volatility of the trading price for the
one or more instruments, as a function of time over the set of time
values.
[0063] For the purpose of illustration only, the one or more
instruments included in the index may comprise the "GOOG", "YHOO",
and "MSFT" stocks. Hence, the index may be an aggregate market
value of these stocks, as a function of time over all trading days
since Jan. 1, 2007. A market value is an aggregation of values of
all assets included in the portfolio at a corresponding time value
in the set of time values. The market value may be measured (e.g.,
denominated) in a reference currency such as the U.S. dollar. For
example, a value of an asset such as an instrument may be a trading
price of that instrument at the closing of a particular trading
day. A value of the reference currency may be its trading value as
denominated in the reference currency. A value of a currency that
is not the reference currency may also be measured in the reference
currency through an exchange rate.
[0064] An index may have a start time value, for example, Jan. 1,
2007; thus, the index does not track the collective value before
the start time value. Similarly, an index may also have an end time
value; thus, the index does not track the collective value after
the end time value. The start time value and/or the end time value
may be explicit or implicit.
[0065] To create an index, any of the object creation mechanisms
may be used. An object creation mechanism may take a first input
that specifies one or more time series for the one or more
instruments. For example, these time series as specified in the
first input may represent trading prices for the "GOOG", "YHOO",
and "MSFT" stocks on all trading days when the stocks are publicly
traded. The object creation mechanism also may take a second input
that specifies a date set. In some embodiments, the date set as
specified in the second input may specify a set of days for which a
collective value of the one or more instruments should be tracked.
For example, the date set may comprise a set of last five trading
days of each quarter since Jan. 1, 2007. The object creation
mechanism may comprise logic to compute the collective value of the
one or more instruments as specified in the first input over the
set of time values as specified in the second input. The object
creation mechanism may create and output an index in the form of a
new time series. Each numeric value in the set of longs or doubles
indicates the collective value of the "GOOG", "YHOO", and "MSFT"
stocks at a time value (e.g., a day) in the set of last five
trading days of each quarter since Jan. 1, 2007.
[0066] The user may provide a token in the form of a string to name
the index so that the definition or computed value of the index can
be subsequently referenced as a named object in combination with
other objects. In an embodiment, any of all the entities that are
involved in specifying, creating and outputting a new index may be
stored or cached in a machine-readable storage medium. In addition,
the definition of new index may also be stored or cached in such a
medium.
4.3 Instrument Group
[0067] An instrument group comprises one or more instruments
selected from a universe of instruments using a filter chain that
is created from zero or more set operations and one or more filter
links. For example, an instrument group may comprise all the stocks
in the S&P Index ("SPX") that are in the technology sector.
Another example of instrument group may be all the stocks in the
financial sector of the S&P Index that have low PE ratios.
[0068] To create an instrument group, an object creation mechanism
may be used. This mechanism may take a first input that specifies
the zero or more set operations. For example, a set operation of
"intersection" may be specified as the first input. The object
creation mechanism also may take a second input that specifies the
one or more filter links. For the purpose of illustration only,
such a filter link may be a criterion that any selected stock must
belong to the bucket of lowest 10% among an input set of
instruments. In some embodiments, graphical user interface 200 of
client 120 may be used to create an instrument group, as shown in
FIG. 2B. A filter view 206 may be used to represents an input set
of instruments to which a filter link may be applied. In this
example, all stocks in the financial sector of the S&P Index
are used as an input set of instruments. These stocks are
represented in an n-tile diagram. This n-tile diagram comprises n
(a positively integer such as ten) buckets, each bucket comprising
substantially a same number of instruments. Each bucket represents
a particular range of 10% PE ratios. Thus, if a stock is in the top
10% among all the stocks in terms of PE ratios, the stock will be
included in the bucket between 90% and 100%. Similarly, if a stock
is in the bottom 10% among all the stocks in terms of PE ratios,
the stock will be included in the bucket between 0% and 10%. A user
at client 120 may perform a range selection 208 to select a desire
range of PE ratios. In the present example, the user selects the
bottom 10% of PE ratios.
[0069] The object creation mechanism may comprise logic to create a
filter chain by evaluating each filter link in the filter chain,
combining the filter link into the filter chain based on the set
operation specified, and generate the instrument group that
comprises the one or more instruments. In the present example,
where the filter link is created using an n-tile diagram. the
object creation mechanism may create and output an instrument group
that comprises a set of instruments that are in the bottom 10% of
PE ratios as indicated in FIG. 2B.
[0070] The user may provide a token in the form of a string to name
the instrument group. For example, this instrument group as
illustrated in FIG. 2B may be called "low PE SPX Financials." In
some embodiments, a text input box 210 may be provided in graphical
user interface 200 to accept input of the string. Subsequently,
this named instrument group may be used in combination with other
objects by a reference to the token.
[0071] In an embodiment, any of all the entities that are involved
in specifying, creating and outputting a new instrument group may
be stored or cached in a machine-readable storage medium. In
addition, the new instrument group may also be stored or cached in
such a medium.
4.4 Portfolio
[0072] A portfolio indicates a market value of included assets as a
function of time over a set of time values. A portfolio may
comprise a start time value from which the market value of the
portfolio is to be tracked. A portfolio may optionally comprise an
end time value after which the market value of the portfolio is no
longer tracked. The set of assets included in the portfolio at any
given time value may comprise a variable number of instruments. The
set of assets may optionally include a certain amount in various
currencies (including currency equivalents).
[0073] To create a portfolio, an object creation mechanism may be
used. This mechanism may take a first input that specifies zero or
more time series for the zero or more instruments. For example,
these time series as specified in the first input may represent
trading prices for the "GOOG", "YHOO", and "MSFT" stocks on all
trading days when the stocks are publicly traded. In some
embodiments, the object creation mechanism may use weight factors
to determine how much of each of these instruments is to be hold in
the portfolio at each time value of a time period starting from the
start time value. The object creation mechanism also takes a second
input that specifies a date set. In some embodiments, the date set
as specified in the second input specifies a set of time values
(e.g., the preceding time period) for which a market value of the
portfolio should be computed. For example, the date set may
comprise a set of all trading days since Jan. 1, 2007. The object
creation mechanism may further take a third input that specifies
the one or more trades over the set of time values as specified in
the second input. Each trade may specify an instrument, a
buy-or-sell indication, a time of trading, and a quantity. The
object creation mechanism may comprise logic to execute, or to
simulate execution of, trades as specified in the third input and
to compute the market value of the portfolio over the set of time
values as specified in the second input, thereby giving rise to a
new portfolio object. Any other metric may be applied to the new
portfolio object to extract information. In addition, the portfolio
object may be used to create another higher-order object. In the
present example, the associated set of time values to which the
long or double values are mapped is the set of time values
specified in the second input. For example, each numeric value in
the set of longs or doubles indicates a collective market value of
all assets in the portfolio at a time value in the set of all
trading days since Jan. 1, 2007.
[0074] The user may provide a token in the form of a string to name
the portfolio so that a subsequent reference can be made to the
token in an expression that involves other objects.
[0075] In an embodiment, any of all the entities that are involved
in specifying, creating and outputting a new portfolio may be
stored or cached in a machine-readable storage medium. In addition,
the new portfolio may also be stored or cached in such a
medium.
4.5 Strategy
[0076] A strategy, as illustrated in FIG. 2C, may be used to
generate a net profit in a time period. A net profit in a time
period is a net gain or loss at the end of the time period. Here,
the net profit may be determined by a number of trades executed
within the time period and market conditions. A block of strategy
code may be used to generate the trades that are to be executed in
connection with the strategy. In some embodiments, the net profit
and the trades may be hypothetical and generated for the purpose of
studying, validating or invalidating a particular trading
strategy.
[0077] The time period may be represented by a date set that
comprises a starting time value corresponding to the beginning of
the time period and optionally an end time value corresponding to
the end of the time period.
[0078] In some embodiments, a strategy comprises an initial
collection of assets at the beginning of the time period. In a
particular embodiment, this initial collection of assets may
comprise only a starting net asset value (212 of FIG. 2C) in a
reference currency such as the U.S. dollar.
[0079] To create a strategy, an object creation mechanism may be
used. This object creation mechanism may take a first input that
specifies a particular date set. Comprising a start time value and
optionally an end time value as previously described, the
particular date set represents a time period where trades may be
generated and executed. For example, the date set may be all
trading days from Jan. 1, 2006 to now. Alternatively, the date set
may be all trading days when the "GOOG" stock trades up.
[0080] The object creation mechanism may take a second input that
specifies a statement block, which when executed generates one or
more trades. Each trade may specify an instrument, a-buy-or-sell
indication, a time of trading, and a quantity. For the purpose of
illustration, the statement block may be displayed in a content
pane 214 on graphical user interface 200 in FIG. 2C. The object
creation mechanism may comprise logic to execute, or to simulate
execution of, the statement block and the trades as generated by
the statement block and to compute the market value of the strategy
over the set of time values as specified in the first input,
thereby creating a new strategy object. Any other metric may be
applied to the new strategy object to extract information. In
addition, the strategy object may be used to create another
higher-order object. Furthermore, the object creation mechanism may
create and output a net profit at the end of the time period. In
the present example, the object creation mechanism may create and
output a net profit of 72,277.21 in the reference currency of US
dollar, as illustrated in 216 of FIG. 3C.
[0081] The user may provide a token in the form of a string to name
the strategy. For example, the strategy in FIG. 2C may be named as
"VLD during rising rates", as indicated in the title bar of
graphical user interface 200 of FIG. 2C. Subsequently, this
strategy may be used to create other higher-order objects.
[0082] In an embodiment, any of all the entities that are involved
in specifying, creating and outputting a new strategy may be stored
or cached in a machine-readable storage medium. In addition, the
new strategy may also be stored or cached in such a medium.
[0083] A user may interact with graphical user interface 200 to
test a trading strategy. For example, a statement block may be
supplied (e.g., pasted) into content pane 214 of FIG. 2C and
executed to create and output a net profit at the end of the time
period. Other statement blocks corresponding to various strategies
of investment may also be tested by supplying each of the other
statement blocks into content pane 214 of FIG. 2C for execution of
trades. For example for the purpose of comparing between different
trading strategies within the same time period and with the same
starting net asset value may be tested in this manner.
[0084] For the purpose of illustration only, the statement block
that is to be executed by a strategy (object) may comprise one or
more rules that can be used to determine the one or more trades, as
illustrated below:
TABLE-US-00001 Setup code:
----------------------------------------- // A Strategy based on
the idea that an instrument that experiences large moves in //
either direction tends to revert to a more normal value. Buy the
instrument // when it crosses its lower Bollinger band; sell when
it crosses its upper // Bollinger band; and always exit the
position once it returns to its moving // average. TimeSeries
series = SPX; Number days = 80; Number stddev = 2.0; TimeSeries
lowerBollingerBand = series.bollingerSingle(days, -1*stddev);
TimeSeries upperBollingerBand = series.bollingerSingle(days,
stddev); TimeSeries mean = series.ma(days);
----------------------------------------- Loop code:
----------------------------------------- if
(series.movesBelow(lowerBollingerBand)) { if (numContracts(series)
<= 0) { hold(series, 100, Enum.PERCENT_OF_NAV); } } else if
(series.movesAbove(upperBollingerBand)) { if (numContracts(series)
>= 0) { hold(series, -100, Enum.PERCENT_OF_NAV); } } else if
(series.movesAbove(mean) || series.movesBelow(mean)) {
exit(series); }
[0085] This statement block as indicated in its comment section
implements a trading strategy with rules of buying 100 units in SPX
if SPX moves below its lower Bollinger band, selling 100 units if
SPX moves above its upper Bollinger band, and exiting the position
in SPX if SPX returns to its moving average.
4.6 Regression
[0086] A regression, as illustrated in FIG. 2D, may be used to
perform predictions, inferences and hypothesis analyses between
independent time series and a dependent time series in the object
model.
[0087] To create a regression, an object creation mechanism may be
used. This object creation mechanism may take a first input that
specifies one or more first time series representing independent
variables in a regression analysis. For example, the one or more
first time series may be ones that are associated with objects like
"Exxon Mobil Corp", "WTI CRUDE FUTURE (1st month generic)", and
"S&P 500 INDEX" in the object model, as indicated in 218 of
FIG. 2D. The object creation mechanism also may take a second input
that specifies a second time series representing a dependent
variable in the regression analysis. The object creation mechanism
may comprise logic to perform the regression analysis that
transforms the one or more first time series into a predicted time
series and compares the predicted time series with the second time
series, thereby creating a new regression object. This new
regression object may be used in part by another object creation
mechanism to create other higher-order objects. The result of the
regression analysis may be presented in a content pane 222 of FIG.
2D.
[0088] The user may provide a token in the form of a string to name
the regression. Subsequently, this regression may be used in
combination with other objects through a reference to its
token.
[0089] In an embodiment, any of all the entities that are involved
in specifying, creating and outputting a new regression may be
stored or cached in a machine-readable storage medium. In addition,
the new regression may also be stored or cached in such a
medium.
5 ADDITIONAL EXAMPLE HIGHER-ORDER OBJECTS
[0090] A user may define an arbitrarily complex object that is
built on top of other objects. For example, liquidity and risk
models may be built as a multi-level object on top of an instrument
group, a portfolio, several indexes, a date set, etc. Similarly, an
index may be built on top of other higher-order objects.
[0091] FIG. 2E illustrates an index that is built on another
higher-order object. The index may be built on top of one or more
time series, all of which belongs to a higher-order object in the
form of an instrument group. In other words, the instrument group,
a higher-order object, is built on top of three time series
associated with zero-order objects (e.g., instruments, economic
index, etc.), while the index uses the instrument group as input.
For the purpose of illustration only, the instrument group may be
"low PE SPX Financials", as illustrated in FIG. 2B. As shown in
FIG. 2E, a collective value for the instrument group may be tracked
in the higher-order index and computed as a function of time over a
time period. This function of time may be displayed in a content
pane 224 of graphical user interface 200, as illustrated in FIG.
2E. In some embodiments, still higher-order indexes may be built on
tope of other objects.
[0092] In some embodiments, a higher-order object may be
represented as a tree. The leaf nodes of the tree are zero-order
objects such as instruments. The tree may additionally and/or
optionally contain non-leaf nodes. The non-leaf nodes are
higher-order objects. In other words, a higher-order object may be
built from building blocks. These building blocks may be zero-order
or higher-order objects. For example, when an index is built from
an instrument group, the instrument group also may be built from a
combination of other higher-order and zero-order objects.
[0093] Any of several object creation mechanisms may be selected by
a user for the purpose of creating a higher-order object.
Definitions for the higher-order objects may be generated by the
object creation mechanism and saved in the system. A definition may
be defined and evaluated at two different times. The results of
evaluation of a definition may change as underlying data changes.
These results may be saved in cache or in permanent storage.
[0094] In some embodiments, types of objects in the object model
may be implemented as classes in an object-oriented language such
as JAVA.RTM., thus allowing easy incorporation of various
properties of one object into another.
6 DYNAMIC SPECIFICATION OF OBJECTS
[0095] In accordance with an embodiment of the present invention,
an input mechanism is provided for a user to enter expressions to
the data analysis system for the purpose of instructing the data
analysis system to create, modify, delete, evaluate, or save
various objects and components in the object model. Here, the term
"input mechanism" includes either a command line interaction
mechanism or a graphic-user-interface based interaction mechanism,
or a combination of the preceding two. In other embodiments, an
input mechanism is not used and objects may be specified
programmatically or at runtime using other mechanisms.
[0096] An expression may comprise one or more tokens separated by
delimiter characters such as a period, parentheses, a comma,
quotation marks, etc. Each token may refer to an economic index, an
instrument, a metric, an input object, an output object, a
parameter, a time series, a higher-order-object, or any
higher-order object in the object model.
[0097] An expression may be evaluated with a certain order. For
example, in a particular embodiment, the expression may be
evaluated according to a precedence ordering among operators.
Additionally and/or optionally, certain optimization logic may be
used to determine whether any tokens in an expression can be
evaluated in parallel.
[0098] Custom metrics and user-defined classes and objects can be
provided to (or plugged into) the system and be immediately made
available for use. In certain embodiments, a modeling language may
be used to define custom metric objects. For example, a user may
specify at a command line interface for creating a new type of
object and provides to the data analysis system a token for this
new type of object. The new type of object, for example, may be a
new metric. However, a modeling language is not required, and the
embodiments that show use of a modeling language herein are
provided merely to illustrate clear examples. Thus, in one
alternative, Javan objects and instance variables may be used to
define custom metric objects programmatically without using a
modeling language to define the objects and instance variables.
[0099] As illustrated in FIG. 2F, in an embodiment that uses a
modeling language, a user may type an expression "(HVOL( )+IVOL(
))/2" as 226 of FIG. 2F to define a new custom metric. For the
purpose of illustration only, "HVOL( )" and "IVOL( )" may be two
tokens for two functions. Tokens for other constructs may also be
used. The user may give a new token "avgvol( )" for this new
metric. Subsequently, as shown in FIG. 2G, the token "avgvol( )"
for the new metric may be displayed as a selectable item in a
dialog pane 230 of FIG. 2G. This new metric may be used together
with an instrument such as "GOOG" to cause a new time series to be
created and displayed. This new time series is produced by
averaging values from two time series as specified by "HVOL( )" and
"IVOL( )", as defined by the user in FIG. 2F.
[0100] The data analysis system may immediately make available this
new type of object (e.g., a new function "avgvol( )") to all users
of the system. The users simply specify the token associated with
the new type of object in subsequent expressions. As shown in FIG.
2H, time series representing "HVOL( )" and "IVOL( )" can be
displayed in a content pane 232 of FIG. 2H, along with a new time
series as specified by the new token (i.e., "avgvol( )").
[0101] In this manner, new types of objects and new types of
expressions can be continuously added to the data analysis system,
which causes the object model to evolve over the time. For example,
a user may continuously define new hypotheses as new object types
or as new instances of existing object types and timely test the
new hypotheses in a rapidly changing market. Evaluations of some of
these hypotheses may be saved or cached along with the definitions
for the hypotheses. These hypotheses can also be recalled,
re-studied, and reused by way of suitable tokens at a later
time.
7 EXAMPLE PROCESS FLOW
[0102] FIG. 3 illustrates an example process that uses a metric to
generate an output object based on one or more time series
determined from one or more input objects.
[0103] FIG. 3 illustrates an example process related to creating
objects in the object model. In block 302, the data analysis system
100 identifies a metric that transforms one or more time series
into an output object. For example, through interacting with a user
at client 120 via graphical user interface 200 illustrated in FIG.
2A, the data analysis system 100 may receive a request from the
user to create a date set. Based on the request, the data analysis
system 100 may identify an existing metric among a plurality of
metrics that output date sets. In an alternative embodiment, the
data analysis system 100 may create a new metric anew that performs
the desired transformation and identify the new metric for the
purpose of creating the date set. For the purpose of illustration,
this particular metric may transform a calendar and a set of
criteria into a date set (i.e., the output object) comprising time
values that come from the calendar and satisfy the set of
criteria.
[0104] In block 304, the data analysis system 100 determines, based
on one or more input objects, the one or more time series. For
example, input object may be the calendar and the set of criteria,
a part of which is displayed in 202 of FIG. 2A. The calendar may be
used to generate the one or more time series.
[0105] In block 306, the data analysis system 100 applies the
metric using the one or more time series, thereby generating a
particular value for the output object. For example, the metric may
be used by the data analysis system 100 to transform the time
series that represents the calendar into a date set in the form of
a time series comprising time values satisfying the set of
criteria.
[0106] In block 308, the data analysis system 100 store, in memory,
one of the metric and the particular value for the output object.
In some embodiments, any of other objects, time series, and
parameters may also be stored. For example, the user may specify a
name for the date set in 204 of FIG. 2A and request the metric that
generates the date set be stored in a physical storage device.
[0107] For the purpose of this invention, other objects including
the higher-order objects and the higher-order objects described
above may also be created in a similar manner. For example, this
example process can be repeated to produce higher-order objects
based on time series determined from higher-order objects or
zero-order objects. In this manner, higher-order objects may be
built on top of higher-order objects in the object model.
8 EXTENSIONS AND ALTERNATIVES
[0108] Data analysis according to the techniques described herein
is not limited to any particular tool or any particular type of
analysis. Thus, the examples of data analysis provided herein are
to be regarded in an illustrative rather than a restrictive
sense.
9 EXAMPLE IMPLEMENTATION HARDWARE
[0109] FIG. 4 is a block diagram that illustrates a computer system
400 upon which an embodiment of the invention may be implemented.
Computer system 400 includes a bus 402 or other communication
mechanism for communicating information, and a processor 404
coupled with bus 402 for processing information. Computer system
400 also includes a main memory 406, such as a random access memory
(RAM) or other dynamic storage device, coupled to bus 402 for
storing information and instructions to be executed by processor
404. Main memory 406 also may be used for storing temporary
variables or other intermediate information during execution of
instructions to be executed by processor 404. Computer system 400
further includes a read only memory (ROM) 408 or other static
storage device coupled to bus 402 for storing static information
and instructions for processor 404. A storage device 410, such as a
magnetic disk or optical disk, is provided and coupled to bus 402
for storing information and instructions.
[0110] Computer system 400 may be coupled via bus 402 to a display
412, such as a cathode ray tube (CRT), for displaying information
to a computer user. An input device 414, including alphanumeric and
other keys, is coupled to bus 402 for communicating information and
command selections to processor 404. Another type of user input
device is cursor control 416, such as a mouse, a trackball, or
cursor direction keys for communicating direction information and
command selections to processor 404 and for controlling cursor
movement on display 412. This input device typically has two
degrees of freedom in two axes, a first axis (e.g., x) and a second
axis (e.g., y), that allows the device to specify positions in a
plane.
[0111] The invention is related to the use of computer system 400
for implementing the techniques described herein. According to one
embodiment of the invention, those techniques are performed by
computer system 400 in response to processor 404 executing one or
more sequences of one or more instructions contained in main memory
406. Such instructions may be read into main memory 406 from
another machine-readable medium, such as storage device 410.
Execution of the sequences of instructions contained in main memory
406 causes processor 404 to perform the process steps described
herein. In alternative embodiments, hard-wired circuitry may be
used in place of or in combination with software instructions to
implement the invention. Thus, embodiments of the invention are not
limited to any specific combination of hardware circuitry and
software.
[0112] The term "machine-readable medium" as used herein refers to
any medium that participates in providing data that causes a
machine to operate in a specific fashion. In an embodiment
implemented using computer system 400, various machine-readable
media are involved, for example, in providing instructions to
processor 404 for execution. Such a medium may take many forms,
including but not limited to, non-volatile media, volatile media,
and transmission media. Non-volatile media includes, for example,
optical or magnetic disks, such as storage device 410. Volatile
media includes dynamic memory, such as main memory 406.
Transmission media includes coaxial cables, copper wire and fiber
optics, including the wires that comprise bus 402. Transmission
media can also take the form of acoustic or light waves, such as
those generated during radio wave and infrared data communications.
All such media must be tangible to enable the instructions carried
by the media to be detected by a physical mechanism that reads the
instructions into a machine.
[0113] Common forms of machine-readable media include, for example,
a floppy disk, a flexible disk, hard disk, magnetic tape, or any
other magnetic medium, a CD-ROM, any other optical medium, punch
cards, paper tape, any other physical medium with patterns of
holes, a RAM, a PROM, and EPROM, a FLASH-EPROM, any other memory
chip or cartridge, a carrier wave as described hereinafter, or any
other medium from which a computer can read.
[0114] Various forms of machine-readable media may be involved in
carrying one or more sequences of one or more instructions to
processor 404 for execution. For example, the instructions may
initially be carried on a magnetic disk of a remote computer. The
remote computer can load the instructions into its dynamic memory
and send the instructions over a telephone line using a modem. A
modem local to computer system 400 can receive the data on the
telephone line and use an infrared transmitter to convert the data
to an infrared signal. An infrared detector can receive the data
carried in the infrared signal and appropriate circuitry can place
the data on bus 402. Bus 402 carries the data to main memory 406,
from which processor 404 retrieves and executes the instructions.
The instructions received by main memory 406 may optionally be
stored on storage device 410 either before or after execution by
processor 404.
[0115] Computer system 400 also includes a communication interface
418 coupled to bus 402. Communication interface 418 provides a
two-way data communication coupling to a network link 420 that is
connected to a local network 422. For example, communication
interface 418 may be an integrated services digital network (ISDN)
card or a modem to provide a data communication connection to a
corresponding type of telephone line. As another example,
communication interface 418 may be a local area network (LAN) card
to provide a data communication connection to a compatible LAN.
Wireless links may also be implemented. In any such implementation,
communication interface 418 sends and receives electrical,
electromagnetic or optical signals that carry digital data streams
representing various types of information.
[0116] Network link 420 typically provides data communication
through one or more networks to other data devices. For example,
network link 420 may provide a connection through local network 422
to a host computer 424 or to data equipment operated by an Internet
Service Provider (ISP) 426. ISP 426 in turn provides data
communication services through the worldwide packet data
communication network now commonly referred to as the "Internet"
428. Local network 422 and Internet 428 both use electrical,
electromagnetic or optical signals that carry digital data streams.
The signals through the various networks and the signals on network
link 420 and through communication interface 418, which carry the
digital data to and from computer system 400, are exemplary forms
of carrier waves transporting the information.
[0117] Computer system 400 can send messages and receive data,
including program code, through the network(s), network link 420
and communication interface 418. In the Internet example, a server
430 might transmit a requested code for an application program
through Internet 428, ISP 426, local network 422 and communication
interface 418.
[0118] The received code may be executed by processor 404 as it is
received, and/or stored in storage device 410, or other
non-volatile storage for later execution. In this manner, computer
system 400 may obtain application code in the form of a carrier
wave.
[0119] In the foregoing specification, embodiments of the invention
have been described with reference to numerous specific details
that may vary from implementation to implementation. Thus, the sole
and exclusive indicator of what is the invention, and is intended
by the applicants to be the invention, is the set of claims that
issue from this application, in the specific form in which such
claims issue, including any subsequent correction. Any definitions
expressly set forth herein for terms contained in such claims shall
govern the meaning of such terms as used in the claims. Hence, no
limitation, element, property, feature, advantage or attribute that
is not expressly recited in a claim should limit the scope of such
claim in any way. The specification and drawings are, accordingly,
to be regarded in an illustrative rather than a restrictive
sense.
* * * * *