`Patent No. 8,510,407
`
`UNITED STATES PATENT AND TRADEMARK OFFICE
`
`BEFORE THE PATENT TRIAL AND APPEAL BOARD
`
`LENOVO HOLDING COMPANY, INC.,
`LENOVO (UNITED STATES) INC., and
`MOTOROLA MOBILITY LLC,
`Petitioners,
`
`v.
`
`DODOTS LICENSING SOLUTIONS LLC,
`Patent Owner.
`
`CASE IPR2019-01279
`Patent No. 8,510,407
`
`DECLARATION OF DOCTOR EARL SACERDOTI, PH.D.
`
`DoDots Exhibit 2004
`
`
`
`
`
`I, Dr. Earl Sacerdoti, Ph.D., declare as follows:
`
`I.
`
`BACKGROUND AND QUALIFICATIONS
`
`1) My name is Earl Sacerdoti. I have practiced in the field of
`
`computer science for 50 years. I am being compensated at the rate of $550
`
`an hour for my testimony in this matter.
`
`2)
`
`I received my Bachelor of Arts in Psychology from Yale
`
`College in 1969. I received both my Master of Science (M.S.) and my
`
`Doctor of Philosophy (Ph.D) degrees in Computer Science from Stanford
`
`University in 1972 and 1975, respectively, and also took courses at
`
`Stanford’s graduate business school in 1983 as part of its American
`
`Electronics Association-sponsored Executive Education Program.
`
`3)
`
`From 1972 until 1979, I worked at the Stanford Research
`
`Institute (now SRI International), initially as a Research Mathematician, and
`
`later as the Associate Director for the Artificial Intelligence Center. In those
`
`roles, I managed and performed research in a variety of subfields within
`
`Artificial Intelligence. In 1973-4 I developed QLISP, an interpreted,
`
`incrementally compilable programming language for AI systems. I am
`
`credited with pioneering "modern problem solving," along with developing,
`
`marketing and participating in research programs in automated and
`
`
`
`1
`
`
`
`
`
`interactive problem solving, natural-language interaction with data bases,
`
`distributed robotics, and programming languages. From 1975 through 1979,
`
`I conceived and managed a project that developed software for a testbed
`
`operated for the US Navy, which offered English-language access to a
`
`database distributed across multiple computers on the Arpanet, the
`
`predecessor to today’s Internet.
`
`4)
`
`After leaving SRI International, I co-founded Machine
`
`Intelligence Corporation, where I served as Director of Research and
`
`Development, Vice President of Engineering, and President of International
`
`Machine Intelligence Corporation. Here, I directed development of the first
`
`general industrial vision system, the first vision-guided industrial robot, and
`
`the first computer-networked industrial robot. I also supervised and
`
`participated in developing the prototype of a data management product, for
`
`which we created a spin-off business named Symantec, Inc., a leading
`
`software publisher.
`
`5)
`
`In 1983 I joined Teknowledge, Inc. as Chief Technical Officer,
`
`and later served as General Manager of its products division and Vice
`
`President of Business Development. In these roles, I managed the
`
`development, sales, and application of two programming languages for
`
`developing expert systems.
`
`
`
`2
`
`
`
`
`
`6)
`
`Since leaving Teknowledge in 1988, I worked primarily as
`
`Principal Consultant for The Copernican Group and subsequently as
`
`Managing Partner for Opero Partners, LLC. In these roles, I provided
`
`management and technical consultation to over 100 companies. Many of
`
`these projects, including work for Sun Microsystems, Apple Computer, and
`
`dozens of early-stage software vendors, involved applications downloadable
`
`from network locations that display content to users. In 1997 I served as
`
`Acting VP, Engineering for Open Minded Solutions, where I developed a
`
`product that generated HTML web pages dynamically from document
`
`descriptions using the SGML standard, a predecessor to XML. I consulted
`
`for Sun Microsystems during 1989-91, where I became aware of the
`
`development of what became its Java language, which was originally created
`
`to program embedded systems. My recent work includes serving on the
`
`Advisory Board and consulting for Linqto, Inc., where I assisted in drafting
`
`and prosecuting US Patent 10,492,041, which discloses a system and method
`
`for easily modifying applications for mobile devices.
`
`7)
`
`In 1994-95, I established the Apple Systems Architecture
`
`group, reporting to Apple's Chief Scientist, to coordinate technology
`
`developments across its business units. There, I developed Apple’s first
`
`technology roadmap. I led the AppleSoft Architecture Council. I executed
`
`
`
`3
`
`
`
`
`
`special projects for the CEO’s Product Strategy Council, including market
`
`and technical strategies for enterprise computing, and for the Internet. In this
`
`role, I believe I introduced Java to the Apple executive team.
`
`8)
`
`I also am the author of a book and over 20 papers and articles
`
`on a wide range of advanced software topics. I am the inventor of U.S.
`
`Patent Number 6,222,540, which discloses an aspect of a downloadable
`
`application for selecting the most appropriate data visualization for a data
`
`set. I am principal inventor of U.S. Patent Number 6,188,403, and co-
`
`inventor of seven other United States Patents: U.S. Patent Numbers
`
`6,954,728, 7,797,168, 7,996,264, 8,407,086, 8,417,535, 8,583,562, and
`
`9,589,274. I am the inventor of an as-yet-unpublished application for a
`
`United States Patent. I am also a co-inventor of several abandoned
`
`applications.
`
`9)
`
`I am a co-founder of the American Association for Artificial
`
`Intelligence (AAAI), and a former member of the editorial boards of
`
`Cognitive Science, Robotics World, and AI Expert, and was Conference
`
`Chair for AIPS-96 (an international conference on automatic planning). I
`
`also am a former member of the Steering Committee of the DECUS AI
`
`Special Interest Group, and program committees of numerous AAAI and
`
`IEEE conferences on both computer science research and applications. I
`
`
`
`4
`
`
`
`
`
`have presented 7 invited conference talks and 4 conference tutorials, and
`
`was a frequent speaker for such groups as DPMA, DECUS, GUIDE, and
`
`SME on technical, management and business issues concerning advanced
`
`software technology and technology transfer.
`
`10) A copy of my latest curriculum vitae, which describes in further
`
`detail my qualifications, responsibilities, employment history, honors,
`
`awards, professional associations, lectures, and publications is submitted
`
`together with this declaration as DoDots Exhibit 2002.
`
`11)
`
`I have reviewed U.S. Patent No. 8,510,407 (“the ’407 Patent”)
`
`(Ex. 1001) to John A. Kembel, et al. I have also reviewed the publications
`
`cited in this declaration.
`
`II. THE PERSON OF ORDINARY SKILL IN THE RELEVANT
`FIELD IN THE RELEVANT TIMEFRAME
`
`12)
`
`I have been informed that “a person of ordinary skill in the
`
`relevant field” is a hypothetical person to whom an expert in the relevant
`
`field could assign a routine task with reasonable confidence that the task
`
`would be successfully carried out at the time of the invention. The
`
`specification of the ’407 patent provides a straightforward explanation in
`
`sufficient detail to permit people with an undergraduate degree in Computer
`
`Science or Computer Engineering to implement the invention. Hence, I
`
`
`
`5
`
`
`
`
`
`believe such a person of skill in the art would have work or educational
`
`experience equivalent to a B.S. degree in Computer Science or Computer
`
`Engineering.
`
`13) Based on my experience, I generally understand the capabilities
`
`of a person of ordinary skill in the relevant field. I have supervised and
`
`directed many such persons over the course of my career.
`
`
`
`III. SUMMARY OF THE ’407 PATENT
`
`14) The ’407 patent describes a system and method “of presenting
`
`distributable computer readable media in response to a user request.” (2:29-
`
`30) It discloses a method for software running on a client computer to
`
`operate to perform this function. The patent distinguishes its approach from
`
`that used by conventional web applications. “A user operating a client
`
`computer typically accesses the Internet by using a viewer application, such
`
`as a browser to view web content provided at a destination address, typically
`
`a web page. In this context, web content and web applications are designed
`
`to fill the entire web page. … There is a growing desire for individual users
`
`to fully control the aggregation and presentation of content and web
`
`applications that appears on a client computer.” (1:56-2:16) “In view of the
`
`
`
`6
`
`
`
`
`
`foregoing, there is a need in the art to provide a technique for accessing
`
`multiple instances of distributable computer readable media in their entirety
`
`simultaneously, where these instances are typically smaller than the full
`
`pages used in current web pages and web applications.” (2:43-47) “An
`
`"application"-type NIM, such as a web calendar or web mail, may be
`
`changed by the user, by the content provider, or by other content, while
`
`advantageously avoiding the need to distribute and support a hard-
`
`coded compiled application.” (21:54-58) “NIMs allow a developer to
`
`provide an application feel without developing custom client applications.”
`
`(26:38-40) (Emphasis added) This section summarizes the specification’s
`
`description of the method and device configuration.
`
`15) Fundamental to the invention is a Networked Information
`
`Monitor (“NIM”), a fully configurable frame (containing one or more
`
`controls) through which content is optionally presented1. (5:21-23) Also
`
`fundamental to the invention is that, in contrast to Java “applets” and other
`
`traditional web applications, the NIM is constructed or instantiated on the
`
`client computer using a NIM definition, which is a data structure that is
`
`stored in a database. “FIG. 13 illustrates a data structure for a NIM
`
`
`1 See below for a full discussion of the interpretation of “Networked Information
`Monitor” and “Networked Information Monitor Template”.
`7
`
`
`
`
`
`
`
`definition, stored in the NIM application server's template database or user
`
`profile database;” (3:63-65).
`
`16) Because the NIM is constructed on the client from a definition,
`
`the invention of the ’407 patent avoids the need to download compiled
`
`applications or applets. “NIMs are extremely flexible, because the definition
`
`of the NIM is content, rather than compiled code.” (21:48-50).
`
`17) The NIM definition is data that is “… stored in the NIM
`
`application server's template database or user profile database” (3:63-65).
`
`The database files which store the NIM definitions are referred to as “NIM
`
`templates”.
`
`18) A NIM cannot be simply downloaded from a server and
`
`executed. Rather, it is instantiated or constructed on the client before it is
`
`employed. “Because the NIM definition contains basic reference
`
`information, such as data to instantiate the NIM and URLs and other
`
`references to where the NIM content is located, a NIM is easily and quickly
`
`distributed, collected, and shared.” (33:47-50)
`
`19) The NIM definition is transmitted to the client device from a
`
`server. “One class of specified networked information handled by request
`
`server module 72 is requests for NIMs. When such a request is received,
`
`request server module 72 searches NIM templates database 74 for the
`
`
`
`8
`
`
`
`
`
`specified NIM. NIM templates database 74 includes a large number of NIM
`
`templates. Each NIM template defines the characteristics of a specific NIM,
`
`including fully configurable frame characteristics, viewer and control
`
`characteristics, and NIM content references.” (6:62-7:2)
`
`20) A “client parser application” then constructs the NIM from the
`
`definition stored in the NIM template. The “client parser application” runs
`
`on the client after it requests the NIM template file from the applications
`
`server and the server delivers that file to the client. After the NIM definition
`
`is delivered, the “client parser application” constructs the NIM. Finally, the
`
`desired content is retrieved by the client and placed in the NIM frame. “The
`
`method comprises the steps of identifying a definition of a Networked
`
`Information Monitor (NIM). A NIM frame is defined for the NIM using the
`
`definition. Content is then retrieved for the NIM. Then, the content is placed
`
`in a NIM viewer defined by the frame.” (2:28-34). “The steps taken to
`
`provide the NIM to a user are shown in FIG.11. … After the user is logged
`
`in and has clicked on the NIM, the applications server 50 retrieves the NIM
`
`definition from the NIM template database 74 using the NIM ID, in step
`
`242, and provides it to the client 20 in step 243. The client 20 receives the
`
`NIM definition from the applications server 50 in step 244, and the client
`
`parser application 38 creates a frame in the display of the user interface 42 in
`
`
`
`9
`
`
`
`
`
`step 245.” (20:7-24) While this description may be associated with one
`
`embodiment of the invention, the specification is consistently clear that NIM
`
`definitions are retrieved from NIM templates that are stored in a database on
`
`a server, and these NIM definitions are subsequently transmitted to a client,
`
`where a “client parser application” employs the NIM definition to build a
`
`NIM. Figure 11, indicating that the NIM frame is built on the client based on
`
`the NIM definition, is reproduced below.
`
`
`
`
`
`
`
`
`
`10
`
`
`
`
`
`IV. CLAIM INTERPRETATION
`
`21)
`
`In proceedings before the USPTO, I understand that claims are
`
`construed using the same standard used by district courts, meaning that
`
`claims are given their ordinary and customary meaning in view of the
`
`specification from the perspective of one skilled in the art. In comparing the
`
`claims of the ’407 patent to the known prior art, I have carefully considered
`
`the ’407 patent based upon my experience and knowledge in the relevant
`
`field. In my opinion, with the exception of “networked information monitor”
`
`and “networked information monitor template”, the claim terms of the ’407
`
`patent are generally used in their ordinary and customary sense as one
`
`skilled in the relevant field would understand them.
`
` “Networked Information Monitor”
`
`22) The ’407 patent describes a Networked Information Monitor
`
`(“NIM”). “As used herein, the term networked information monitor or NIM
`
`refers to a fully configurable frame with one or more controls; the frame
`
`through which content is optionally presented.” (5:21-23) “… [A] NIM is
`
`defined as a frame that contains a collection of controls, or functional units,
`
`such as a web rendering control or a GIF rendering control. The NIM frame
`
`surrounds a viewer, which displays the addressed content. The [NI]M has a
`
`defined layout or arrangement of the controls, and defined initialization
`
`
`
`11
`
`
`
`
`
`input data, e.g. data and URL[s], for each control or element, in the NIM.”
`
`(21:33-9).
`
`23) The ’407 patent further emphasizes that a NIM is distinct from
`
`an application. “NIMs allow a developer to provide an application feel
`
`without developing custom client applications.” (26:38-40)
`
`24) A client application, by contrast, was understood in the art to be
`
`an executable module, possibly together with data used in the module’s
`
`operation. An application would generally be either composed from source
`
`code that had been previously compiled or otherwise processed into the
`
`module, or would consist entirely of source code and associated data that
`
`could be interpreted at run time.
`
`25) As discussed above, the NIM is distinct from the NIM
`
`definition or template that defines it. “Each NIM template defines the
`
`characteristics of a specific NIM including fully configurable frame
`
`characteristics, viewer and control characteristics, and NIM content
`
`references.” (6:66-7:2)
`
`26) Hence, I believe one of ordinary skill in the art would
`
`understand “networked information monitor” to mean “a fully configurable
`
`frame (containing one or more controls) through which content is optionally
`
`presented.”
`
`
`
`12
`
`
`
`
`
`27) Dr. Madisetti agrees that a NIM is “a fully configurable frame
`
`with one or more controls” through which content is presented to the user.
`
`Id., 5:21-24.” (Madisetti at ¶33) But, as discussed below, Dr. Madisetti and
`
`the petition erroneously conflate the NIM and NIM template.
`
`
`
`“Networked Information Monitor Template”
`
`28)
`
`I have been informed that, in construing the claims of a patent,
`
`distinct terms in the claims must be assigned distinct meanings. “Networked
`
`Information Monitor” is a distinct term from “Networked Information
`
`Monitor Template”. Thus, any interpretation of prior art which conflates
`
`these two terms as PETITION FOR INTER PARTES REVIEW OF
`
`UNITED STATES PATENT NO. 8,510,407 PURSUANT TO 35 U.S.C. §§
`
`311–319, 37 C.F.R. § 42 (“the petition”) and Dr. Madisetti do is inherently
`
`incorrect.
`
`29) The term “template” has a plain and ordinary meaning in the
`
`art. One of ordinary skill in the art would understand it to be a format or
`
`pattern, and to be a data structure, not executable code. (These data
`
`structures may contain elements that consist of executable code, but the
`
`template itself is not executable.) In addition to the intrinsic support for this
`
`interpretation offered by the specification itself and discussed below,
`
`
`
`13
`
`
`
`
`
`substantial external support for this interpretation is provided in numerous
`
`technical publications and in standard dictionaries. For example,
`
`Lexico.com, a collaboration between Dictionary.com and Oxford University
`
`Press, defines “template (computing)” as “A preset format for a document or
`
`file, used so that the format does not have to be recreated each time it is
`
`used.” (https://www.lexico.com/en/definition/template). A true and correct
`
`copy of the pertinent portion of this reference is attached as Exhibit A.
`
`30) Merriam-Webster defines it as “something that establishes or
`
`serves as a pattern.” It further defines it as “computers : a computer
`
`document that has the basic format of something (such as a business letter,
`
`chart, graph, etc.) and that can be used many different times”
`
`(https://www.merriam-webster.com/dictionary/template). A true and correct
`
`copy of the pertinent portion of this reference is attached as Exhibit B.
`
`31)
`
`“Template” is referenced in numerous technical publications
`
`describing software implementations predating the filing of the ’407 patent.
`
`Exemplary citations from Cisco Systems, the US Forest Service, Argonne
`
`National Laboratory, and the U.K Royal Signals and Radar Establishment
`
`and others are cited below. In every case, the template is a format or pattern,
`
`and is a data structure, not executable code.
`
`
`
`14
`
`
`
`
`
`32)
`
`“A Template is a file that contains information on the
`
`dimensions of the screen, the prompts, and data fields that are repeatedly
`
`used in a majority of studies (i.e., date, location, observer). A Template is
`
`different from a Screen. A Template is used as a starting point to create a
`
`screen. A Screen is a finished product using a Template as a building block.”
`
`(USDA Forest Service Gen. Tech. Rep. PSW-GTR-148. 1994, pp. 2-3)
`
`(https://www.fs.fed.us/psw/publications/documents/psw_gtr148/psw_gtr148.
`
`pdf). A true and correct copy of the pertinent portion of this reference is
`
`attached as Exhibit C. This template contains information that helps define a
`
`screen; it is not executable code.
`
`33)
`
`“Descriptions written in the Jasmine description language are
`
`called templates. Templates have a simple declarative syntax that is used to
`
`represent the relations between software components.” (Keith Marzullo &
`
`Douglas Wiebe, “Jasmine: A Software System Modelling Facility”, ACM,
`
`1986, p. 123)
`
`(http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.580.2962&rep=r
`
`ep1&type=pdf) A true and correct copy of the pertinent portion of this
`
`reference is attached as Exhibit D. This template is declarative; it is not
`
`executable. It defines relationships between software elements.
`
`
`
`15
`
`
`
`
`
`34)
`
`“The database directories contain IOC database files and/or
`
`template and substitution files used to generate database files. If templates
`
`are used then whenever a template or substitution file is modified the
`
`command gnumake will recreate the database file(s).” “xxxApp/xxxDb
`
`Executing gnumake in this directory creates the link for dbd and also
`
`generates database instance files from templates.” (Marty Kraimer and Janet
`
`Anderson, “EPICS IOC Applications Building and Source Release Control”,
`
`Argonne National Laboratory, Advanced Photon Source, July 17, 1997, pp.
`
`7, 17)
`
`(https://epics.anl.gov/EpicsDocumentation/AppDevManuals/iocAppBuildSR
`
`control.html) A true and correct copy of the pertinent portion of this
`
`reference is attached as Exhibit E. Like the NIM template, the EPICS
`
`template is data used by a software program (here, invoked by the gnumake
`
`command) to generate a file (here, a database file) based on the definition in
`
`the template.
`
`35)
`
`“Virtual interface templates are serial interface configurations
`
`with no hardware associations, and virtual access interfaces are virtual
`
`interfaces that are created, configured dynamically, and freed as needed”….
`
`“virtual interface template--Generic configuration of an interface for a
`
`certain purpose or configuration common to certain users, plus router-
`
`
`
`16
`
`
`
`
`
`dependent information.” (“Virtual Interface Template Service”, Cisco
`
`Systems Inc., copyright 1989-1997, pp. 2-3)
`
`(http://employees.org/univercd/Feb-
`
`1998/cc/td/doc/product/software/ios112/vtemp.htm) A true and correct copy
`
`of the pertinent portion of this reference is attached as Exhibit F. This
`
`template is a configuration (i.e. declarative specification) that defines a
`
`virtual interface.
`
`36)
`
`“Template A pattern from which components may be created
`
`during building. The creation of these components is controlled by
`
`definitions within composite templates.” (p. F – 7) (“The Official Handbook
`
`of MASCOT”, Joint IECCA & MUF Committee on MASCOT, June, 1987,
`
`Computing Division, Royal Signals and Radar Establishment, Malvern,
`
`Worcestershire, England.) (http://async.org.uk/Hugo.Simpson/MASCOT-
`
`3.1-Manual-June-1987.pdf) A true and correct copy of the pertinent portion
`
`of this reference is attached as Exhibit G. This template is a pattern; it is data
`
`used by a software program to generate application software, based on the
`
`definition in the template, for a functional system.
`
`37) As discussed above, the specification of the ’407 patent
`
`carefully distinguishes between the NIM and a template or definition of the
`
`NIM.
`
`
`
`17
`
`
`
`
`
`38) The NIM definition is a data structure. “FIG. 13 illustrates a
`
`data structure for a NIM definition, stored in the NIM application server's
`
`template database or user profile database;” (3:63-65). “The home NIM
`
`definition is formed by general parameters and commands found in
`
`“session_config” as well as customized parameters and commands in the
`
`processed user profile.” (13:34-7). “NIMs are extremely flexible, because
`
`the definition of the NIM is content, rather than compiled code.” (21:48-50).
`
`“As shown in the exemplary embodiment of FIG. 13, the definition of a
`
`NIM includes tags that identify the NIM 270, define and configure the NIM
`
`frame 271, specify and layout the controls 273 in the NIM viewer, and
`
`specify parameters to initialize all the NIM' s components with content or
`
`data.” (21:61-5).
`
`
`
`18
`
`
`
`
`
`39) The exemplary data structure of the NIM definition, depicted in
`
`Figure 13, is reproduced below.
`
`40) The specification generally refers to the NIM template as a
`
`database record containing a definition of or for the NIM. “After the user is
`
`logged in and has clicked on the NIM, the applications server 50 retrieves
`
`the NIM definition from the NIM template database 74 using the NIM ID, in
`
`step 242, and provides it to the client 20 in step 243.” (20:18-21). “It will be
`
`appreciated that these URLs need not be the same as the initialization URLs
`
`
`
`19
`
`
`
`
`
`in the "raw" NIM definition stored in the NIM template database 74 on
`
`applications server 50, …” (21:25-28).
`
`41) A NIM template, then, which is a NIM definition stored in a
`
`database, is a data structure in a database record.
`
`42) NIM definitions define the NIM frame and its controls. “A NIM
`
`frame is defined for the NIM using the definition.” (2:62-3). “In fact, the
`
`home NIM definition regulates the actual appearance of the home NIM.”
`
`(13:33-4). “The user's profile, stored in the user profile database 76, includes
`
`the NIM definition for each of the NIMs previously collected, and possibly
`
`altered, by each user. The NIM definitions, as discussed above, includes the
`
`NIM frame definition and the definition of the controls for filling the viewer
`
`within the frame with content.” (21:9-14). But, as discussed above, the NIM
`
`templates cannot be executed, directly display the frame, or implement the
`
`controls. “NIMs are extremely flexible, because the definition of the NIM is
`
`content, rather than compiled code.” (21:48-50).
`
`43) The term “definition” also has a plain and ordinary meaning. As
`
`with “template”, a definition is understood to be declarative, as in a
`
`statement. Lexico.com, a collaboration, between Dictionary.com and Oxford
`
`University Press, defines “definition” as “1. A statement of the exact
`
`meaning of a word, especially in a dictionary. … 1.1 An exact statement or
`
`
`
`20
`
`
`
`
`
`description of the nature, scope, or meaning of something.”
`
`https://www.lexico.com/en/definition/definition (Emphasis added) A true
`
`and correct copy of the pertinent portion of this reference is attached as
`
`Exhibit H. Merriam-Webster defines it as “1a: a statement of the meaning of
`
`a word or word group or a sign or symbol [] b: a statement expressing the
`
`essential nature of something …” https://www.merriam-
`
`webster.com/dictionary/definition (Emphasis added) A true and correct copy
`
`of the pertinent portion of this reference is attached as Exhibit I.
`
`44) Critically, it is known that the definition of a thing differs from
`
`the thing itself. One can stave off hunger by eating a meal. One cannot do so
`
`by eating the definition of a meal.
`
`45) NIM definitions (and the NIM templates that hold them) are,
`
`advantageously, significantly smaller than the NIMs they define. “Each NIM
`
`definition contains just enough information to define and initialize the NIM's
`
`components (NIM frame, controls, etc.). For example, this information may
`
`contain data to configure the skeleton or frame that is filled in by NIM
`
`content from a developer's server. The NIM definition is therefore fairly
`
`small in size (~2K), and is therefore easily distributable as an XML file or
`
`Blob (binary large object), which is communicated using the same
`
`mechanisms (HTTP/ HTTPS requests) as regular Web pages.” (33:55-63).
`
`
`
`21
`
`
`
`
`
`46) The specification is clear that a NIM definition or NIM
`
`template is not simply compiled code. “NIMs are extremely flexible,
`
`because the definition of the NIM is content, rather than compiled code.”
`
`(21:48-50) Thus a NIM template or the NIM definition it holds cannot
`
`themselves be executable modules. Hence, a NIM template cannot be an
`
`executable application or applet, and an executable application or applet
`
`cannot be a NIM template.
`
`47) The specification discloses multiple advantages of employing a
`
`NIM template storing a data structure that defines a NIM. None of these
`
`advantages of the invention that are cited in the specification would be
`
`realized were the NIM and the NIM template interpreted to be the same, or
`
`were the NIM template to be interpreted to be an application or an applet.
`
`48) First, because the NIM template does not contain the content to
`
`be displayed within the NIM, but rather a specification of that content, the
`
`content can be located on a server distinct from the one containing the NIM
`
`definition. “System 10 is highly scalable and thus supports a large number of
`
`users. This scalability stems from the fact that the server 50 is delivering the
`
`definition associated with a NIM. The content displayed in the NIM may be
`
`located on a separate computer.” (7:29-34). One of skill in the art would
`
`understand that this enables better scalability by separating the web server
`
`
`
`22
`
`
`
`
`
`within server that interfaces with the client user interface from the web
`
`servers that serve content.
`
`49) Second, because the NIM templates contain definitions that are
`
`significantly smaller than the NIMs they define, those definitions can be
`
`stored within each user’s profile, and can also be periodically updated. “In
`
`general, a processed user profile includes three major components: (i) a
`
`definition of each NIM associated with the user, (ii) a description of each
`
`pack associated with the user and, (iii) the last state of each home NIM
`
`associated with a user.” (12:44-8). This permits the user profile, including
`
`definitions of all NIMs in current use, to be stored upon logout and
`
`optionally during the user’s computing session. “When the user wishes to
`
`log out of system 10, the processed user profile is transferred from client 20
`
`to server 50. When web server 58 receives the processed user profile, it
`
`passes the processed user profile to user profile database manager 100. User
`
`profile database manager 100 stores the processed user profile as the
`
`unprocessed user profile 76 corresponding to the user. … In some
`
`embodiments, the processed user profile is periodically transferred, in its
`
`entirety or incrementally, from client 20 to server 50 and saved in the
`
`manner described in the log out procedure above. Such timed periodic or
`
`event based backup procedures are possible because NIM definitions are
`
`
`
`23
`
`
`
`
`
`efficiently described, thus the absolute size of a processed user profile
`
`remains relatively small. Accordingly, timed backups of a processed user
`
`profile to user profile database 76 are possible without extensive use of
`
`system 10 bandwidth or server 50 resources.” (12:60-13:13) One of skill in
`
`the art would understand that this permits the system to recreate the state of
`
`the user’s session after the user logs out and later logs in again, or if the
`
`system fails unexpectedly during the user’s session.
`
`50) Third, the small size of the NIM template makes the system
`
`scalable. “System 10 is highly scalable and thus supports a large number of
`
`users. This scalability stems from the fact that the server 50 is delivering the
`
`definition associated with a NIM.” (7:29-31).
`
`51) Fourth, the use of a NIM template to define the NIM permits
`
`the user’s customizations of the visual appearance of their NIMs to be
`
`efficiently stored and retrieved, while maintaining the quality of the
`
`functional aspects of each NIM that are common among users. Additionally,
`
`the developer of a NIM can store data defining the default viewer graphical
`
`user interface in the system level file, while each user can override the
`
`default and store their customized viewer graphical user interface in their
`
`user profile. “The home NIM definition is formed by general parameters and
`
`commands found in "session_config" as well as customized parameters and
`
`
`
`24
`
`
`
`
`
`commands in the processed user profile. The division of the home NIM
`
`definition between a system level file and a user level file represents a
`
`balance in the tension between the need for a system 10 host to insure a
`
`consistent level of quality, through the proper implementation of general
`
`parameters and commands, and the desire of each user to create highly
`
`customized home NIMs.” (13:34-43).
`
`52) Fifth, the use of a NIM template to define the NIM permits a
`
`user to efficiently share one or more NIMs with other users. This is more
`
`efficient because only the NIM template, not the NIM itself, need be
`
`uploaded from the user’s client device. (15:30-16:9)
`
`53) Finally, because NIM templates contain content rather than
`
`executable code to define the NIMs, they can be extremely flexible. “The
`
`NIM definition defines the structure of the NIM, and everything that is
`
`visible in a NIM is based on standard Internet content, such as HTML,
`
`dHTML, or GIFs, and is referenced or pointed to by the NIM definition. An
`
`"application"-type NIM, such as a web calendar or web mail, may be
`
`changed by the user, by the content provider, or by other content, while
`
`advantageously avoiding the need to distribute and support a hard-coded
`
`compiled application. The definition of a NIM thus includes everything that
`
`is needed for