IN THE UNITED STATES PATENT AND TRADEMARK OFFICE
`
`––––––––––
`
`BEFORE THE PATENT TRIAL AND APPEAL BOARD
`
`––––––––––
`
`NETFLIX, INC.,
`
`Petitioner,
`
`v.
`
`CA, INC.,
`
`Patent Owner.
`
`––––––––––
`
`Case No. IPR2022-00322
`
`U.S. Patent 8,656,419
`
`––––––––––
`
`Declaration of H. V. Jagadish, Ph.D.
`
`Netflix, Inc. - Ex. 1003, Page 000001
`IPR2022-00322 (Netflix, Inc. v. CA, Inc.)
`
`

`

`
`
`
`I. 
`II. 
`
`TABLE OF CONTENTS
`
`III. 
`
`VI. 
`
`OVERVIEW OF THE TECHNOLOGY ......................................................... 4 
`THE ’419 PATENT ....................................................................................... 11 
`A.  Overview ............................................................................................. 11 
`B. 
`Prosecution History ............................................................................. 16 
`C. 
`Priority Date ........................................................................................ 20 
`D. 
`Challenged Claims .............................................................................. 20 
`SUMMARY OF THE PRIOR ART .............................................................. 20 
`A. 
`Invalidity Grounds ............................................................................... 21 
`B. 
`Verbeke (Exhibit 1004) ....................................................................... 21 
`C. 
`Jalan (Exhibit 1005) ............................................................................ 25 
`D. 
`Neiman (Exhibit 1006) ........................................................................ 28 
`IV.  LEVEL OF ORDINARY SKILL IN THE ART ........................................... 29 
`V. 
`CLAIM CONSTRUCTION .......................................................................... 31 
`A. 
`“a procedure of an application” / “a procedure of the
`application” ......................................................................................... 31 
`INVALIDITY ................................................................................................ 33 
`A.  Ground 1: Claims 1-4, 6-10, 12, 13, 15, 16, and 18 are
`Rendered Obvious in View of Verbeke ............................................... 33 
`1. 
`Independent Claims 1, 12, and 18 ............................................. 33 
`2. 
`Dependent Claim 2 ................................................................... 79 
`3. 
`Dependent Claim 3 ................................................................... 83 
`4. 
`Dependent Claim 4 ................................................................... 87 
`5. 
`Dependent Claim 13 ................................................................. 91 
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000002
`
`

`

`B.
`
`Dependent Claim 6 ................................................................... 91
`6.
`Dependent Claims 7, 8, and 15 ................................................. 94
`7.
`Dependent Claims 9 and 16 ...................................................... 97
`8.
`Dependent Claim 10 ............................................................... 100
`9.
`Grounds 2 and 3: Claims 5, 11, 14, 17, 19, and 20 are Rendered
`Obvious in View of Verbeke and Jalan; and are Rendered
`Obvious in View of Verbeke, Jalan, and Neiman ............................. 103
`1.
`Combination of Verbeke and Jalan ........................................ 103
`2.
`Combination of Verbeke, Jalan, and Neiman ......................... 107
`3.
`Dependent Claims 5 and 14 .................................................... 111
`4.
`Dependent Claims 11, 17, 19, and 20 ..................................... 119
`VII. BACKGROUND AND QUALIFICATIONS ............................................. 131
`A.
`Compensation .................................................................................... 133
`B. Materials and Other Information Considered ................................... 133
`VIII. UNDERSTANDING OF THE LAW .......................................................... 133
`IX. RESERVATION OF RIGHTS .................................................................... 134
`APPENDIX 1: CURRICULUM VITAE OF H. V. JAGADISH .......................... 135
`APPENDIX 2: MATERIALS CONSIDERED IN THE PREPARATION OF
`THIS DECLARATION ...............................................................................162
`APPENDIX 3: CHALLENGED CLAIMS ............................................................164
`APPENDIX 4: UNDERSTANDING OF THE LAW ...........................................171
`
`Netflix, Inc. - Ex. 1003, Page 000003
`
`

`

`I, H.V. Jagadish, declare as follows:
`
`1.
`
`My name is H.V. Jagadish. I am the Bernard A Galler Collegiate
`
`Professor of Electrical Engineering and Computer Science at the University of
`
`Michigan, Ann Arbor and the Director of the Michigan Institute for Data Science
`
`at the University of Michigan, Ann Arbor. I have prepared this report as an expert
`
`witness retained by Netflix, Inc. In this report I give my opinions as to whether
`
`certain claims of U.S. Patent No. 8,656,419 (“the ’419 patent”) are valid. I provide
`
`technical bases for these opinions as appropriate.
`
`2.
`
`This report contains statements of my opinions formed to date and the
`
`bases and reasons for those opinions. I may offer additional opinions based on
`
`further review of materials in this case, including opinions and/or testimony of
`
`other expert witnesses. I make this declaration based upon my own personal
`
`knowledge and, if called upon to testify, would testify competently to the matters
`
`contained herein.
`
`I.
`
`OVERVIEW OF THE TECHNOLOGY
`
`3.
`
`4.
`
`The ’419 patent generally relates to distributed computing.
`
`Distributed computing concepts have been known for decades. Ex.
`
`1008 (Kisor), 3:19-21; Ex. 1009 (Downs), 3:10-29; Ex. 1010 (Fellenstein),
`
`¶¶[0042]-[0044]. Often, distributed computing involves a client computing device
`
`submitting some type of computing job or task, such as the performance of a
`
`Netflix, Inc. - Ex. 1003, Page 000004
`
`

`

`portion of an application, to a set of computers (called a grid, framework, server
`
`farm, etc.), and the set of computers placing the job on one or more of the
`
`computers of the set (a node, server, worker, etc.) to perform the task. Id. Initially,
`
`distributed computing focused on placing particular tasks on servers that were best
`
`able to handle the task based on their hardware or software configurations and
`
`processing load. Id. As distributed computing concepts advanced and the
`
`heterogeneity and capability of the servers increased, systems would also
`
`sometimes provide code to perform tasks to the server nodes. Ex. 1011 (Harris),
`
`6:9-14; Ex. 1006 (Neiman), ¶[0113]; Ex. 1009 (Downs), 4:10-23.
`
`5. While distributed computing may differ in forms, the common thread
`
`in each is that the distributed system utilizes components arranged on different
`
`networked computers that coordinate their actions via messaging to achieve a
`
`common goal, such as the processing of a particular job, in a way transparent to a
`
`user submitting the job. See Ex. 1007 (Tanenbaum)1, pp. 2-4; Ex. 1005 (Jalan),
`
`¶[0004]. In short, as described in Tanenbaum, a “distributed system is a collection
`
`of independent computers that appears to its users as a single coherent system.” Ex.
`
`1 Tanenbaum bears a copyright date of 2007 and includes Library of Congress
`
`Cataloging-in-Publication Data on its copyright page. I was familiar with
`
`Tanenbaum by 2008-2009.
`
`Netflix, Inc. - Ex. 1003, Page 000005
`
`

`

`
`
`1007 (Tanenbaum), p. 2; see also Ex. 1011 (Harris), 1:30-40. Distributed systems
`
`make it easy for numerous users to access remote resources, and to share them in a
`
`controlled and efficient way, and in many cases, across networks and across a
`
`diverse geographic area. Ex. 1007 (Tanenbaum), pp. 3-4; Ex. 1011 (Harris), 1:15-
`
`40.
`
`6.
`
`Distributed Systems: From a systemic viewpoint, there are many
`
`types of distributed computing arrangements, including grid computing systems
`
`consisting of nodes of differing hardware, software, and networks; cluster
`
`computing systems consisting of groups of similar workstations on a local area
`
`network; and peer-to-peer systems consisting of self-organizing nodes that take
`
`advantage of distributed resources. In each system, some type of scheduler, master
`
`node, controller, etc. – rather than the client submitting the job – decides which
`
`tasks are sent to which nodes. See, e.g., Ex. 1006 (Neiman), ¶¶[0037]-[0038]; Ex.
`
`1007 (Tanenbaum), pp. 17, 44; Ex. 1012 (Talia), p. 1; Ex. 1011 (Harris), 4:56-5:2;
`
`Ex. 1014 (Bacthavachalu), 3:57-4:44; Ex. 1016 (Broussard), ¶[0044]; Ex. 1017
`
`(Barsness), ¶¶[0024]-[0025], [0035]. See also Ex. 1007 (Tanenbaum), Fig. 1-6; Ex
`
`1013 (El-Desoky), Fig. 1, reproduced below:
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000006
`
`

`

`
`
`The individual computers making up each system may be referred to as “nodes.”
`
`Ex. 1007 (Tanenbaum), p. 17; Ex. 1013 (El-Desoky), p. 2; Ex. 1014
`
`(Bacthavachalu), 3:57-4:7.
`
`7.
`
`Distributed Processing: To process a job using these hardware
`
`configurations for distributed computing, the job, such as the running of an
`
`application, must be divided into multiple discrete tasks or operations (sometimes
`
`themselves called “jobs”) so the tasks can be distributed amongst the different
`
`nodes and processed individually. Different methods are used to subdivide each
`
`job into subtasks following a logical division of the original job such that each
`
`subtask can be independently managed. See, e.g., Ex. 1004 (Verbeke), Fig. 5,
`
`¶¶[0071], [0074] (multiple tasks of a job are distributed to different nodes); Ex.
`
`1005 (Jalan), Abstract, FIGS. 1, 2, ¶¶[0098]-[0099] (a master process spawns
`
`parallel slave processes to be executed on different nodes); Ex. 1006 (Neiman),
`
`Abstract, FIG. 9, ¶¶[0116]-[0120] (a parent job configured to produce descendant
`
`jobs for computation on different nodes); Ex. 1007 (Tanenbaum), p. 23 (nested
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000007
`
`

`

`
`
`transactions provide a natural way of distributing transactions); Ex. 1018
`
`(Woodgeard), ¶[0004] (data and task decomposition); Ex. 1011 (Harris), 7:45-8:56
`
`(large processing problems are broken up into “grid packets”). Individual tasks
`
`were known to run in different programming languages, and on different operating
`
`systems, on the individual nodes. Ex. 1014 (Bacthavachalu), 6:41-45; Ex. 1006
`
`(Neiman), ¶¶[0049], [0087], [0089].
`
`8.
`
`Transparency: As discussed in Tanenbaum, one of the goals of
`
`distributed computing is to “hide the fact that its processes and resources are
`
`physically distributed across multiple computers. A distributed system that is able
`
`to present itself to users and applications as if it were only a single computer
`
`system is said to be transparent.” Ex. 1007 (Tanenbaum), p. 4. Transparency, a
`
`central feature of distributed computing, eliminates, for example, the necessity for
`
`a user to manage the processing of multiple applications on computer systems that
`
`may run on different operating systems or to manage the location of resources that
`
`may be moving. Ex. 1007 (Tanenbaum), p. 5. Transparency can be implemented
`
`in many ways; for example, by using “middleware” to distribute operations to
`
`nodes. See, e.g., Ex. 1004 (Verbeke), ¶¶[0076], [0071] (“a task dispatcher group
`
`distributes individual tasks to workers”); Ex. 1006 (Neiman), ¶[0066]-[0067] (tasks
`
`submitted via a transaction manager); Ex. 1007 (Tanenbaum), p. 23, Fig. 1-10 (a
`
`“transaction processing monitor” that “handleddistributed (or nested)
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000008
`
`

`

`
`
`transactions”); Ex. 1011 (Harris), Fig. 1, 5:27-6:4 (a “grid switch” routes requests
`
`“based on a DNS round robin process”); Ex. 1014 (Bacthavachalu) 6:23-52, 9:43-
`
`35 (a queue service and a scheduling component scheduling jobs among nodes
`
`based on job dependencies and load balancing). The user submitting the job in
`
`each system does not know, and does not care, which node will process its job.
`
`9.
`
`Dependent Processes and Tasks: The scheduling of tasks on a
`
`framework to run dependent on one another (e.g., task B uses the results from task
`
`A) has long been known. See, e.g., Ex. 1006 (Neiman), ¶¶[0015]-[0016], [0039],
`
`[0041] (teaching parent tasks with descendent tasks); Ex. 1014 (Bacthavachalu),
`
`4:30-4:44, 6:23-6:52, 8:63-9:12 (teaching calculating job dependencies and using
`
`outputs from some jobs on some nodes as inputs to summary jobs on different
`
`nodes).
`
`10. Knowledge Sharing: Distributed computing systems have been
`
`known to share information, data, instructions, code, and results between and
`
`among nodes of the system. See Ex. 1007 (Tanenbaum), pp. 3-4 (sharing
`
`hardware, software, groupware, storage); Ex. 1011 (Harris), 1:15-40 (teaching
`
`computing resources sharing and “applications and data sharing”). For example, it
`
`has been known since the 1990s to transfer code between nodes to where it is
`
`needed (known as “code mobility” or “code migration”), such as to a node that has
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000009
`
`

`

`
`
`availability to run a distributed task but does not have the code installed. See Ex.
`
`1015 (Fuggetta), pp. 1-2, 11-12, Table 2; Ex. 1007 (Tanenbaum), pp. 103-104.
`
`11. Results: It has also long been known to return results of the task(s)
`
`being performed to the task submitter, either directly by some type of manager or
`
`through placing the result(s) in a log file or other storage in the distributed system
`
`that may be accessed by the task submitter. Ex. 1006 (Neiman), ¶¶[0044], [0066]-
`
`[0067], [0111]; Ex. 1009 (Downs), 4:10-23; Ex. 1011 (Harris), 5:2-14; Ex. 1017
`
`(Barsness), ¶¶[0006], [0034]; Ex. 1018 (Woodgeard), ¶[0024].
`
`12. Object-Oriented Distributed Systems: As object-oriented
`
`programming has become dominant, it has been advantageously used in distributed
`
`systems. Object-oriented programming utilizes “objects” and “classes” that
`
`describe the object (e.g., with variables, properties, procedures, and events). This
`
`logical structure naturally lends itself to distributed implementations where objects
`
`and classes may be stored and run on different nodes. Ex. 1007 (Tanenbaum), p.
`
`443; Ex. 1005 (Jalan), ¶¶[0010]-[0011]. Distributed object-based systems employ
`
`a class loader on a node to retrieve classes from other nodes as needed. See Ex.
`
`1004 (Verbeke), ¶¶[0004], [0005]; Ex. 1007 (Tanenbaum), p. 423; Ex. 1011
`
`(Harris), 2:14-38; Ex. 1015 (Fuggetta), p. 8; Ex. 1016 (Broussard), ¶[0046]; Ex.
`
`1017 (Barsness), ¶[0011]. For example, when a class is needed by the executing
`
`code, or triggered by an application, the class loader retrieves the class from a
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000010
`
`

`

`
`
`server or remote host, and then loads the class so that the corresponding code may
`
`be executed. See id.
`
`13. While various types of hardware implementations, software calls,
`
`discrete processes, and particular methodologies for distributed computing have
`
`been developed over the years, as briefly discussed above, the concepts developed
`
`for these various applications are generally broadly interchangeable, such that
`
`techniques useful for one hardware and software implementation are applicable to
`
`other hardware and software implementations, and such that concepts and
`
`methodologies developed for one application might be generally applied across
`
`similar applications. This is demonstrated by the example art discussed above.
`
`14. Accordingly, the concepts and architectures of distributed computing
`
`were well-known by 2008-2009.2
`
`II. THE ’419 PATENT
`A. Overview
`15. The ’419 patent states it “relates generally to distributed computing.”
`
`Ex. 1001 (’419 patent), 1:5-7. In its Summary of the Invention section, the ’419
`
`patent states:
`
`
`2 “2008-2009,” as used herein, is intended to represent the general time frame
`
`before the July 2, 2009 filing date of the ’419 patent.
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000011
`
`

`

`
`
`According to one embodiment a first node of a network communicates
`with a second node of the network. The first node tells the second
`node to perform an operation and how to perform the operation using
`computer code. Additionally, the first node tells the second node what
`to do with the result of the operation.
`
`Ex. 1001 (’419 patent), 1:19-24. This embodiment description is no different from
`
`many standard client/server processes known to a POSITA3 by 2008-2009, as it
`
`describes only a one-to-one client/server arrangement, not a distributed system.
`
`Despite this, the ’419 patent indicates that its arrangement provides “one or more
`
`technical advantages,” including that: (i) “an operation may be called without
`
`knowing the node that will perform the operation;” and (ii) “nodes may share
`
`knowledge for performing an operation” to allow “an application to be distributed,
`
`with different nodes performing different operations of the application.” Ex. 1001
`
`(’419 patent), 1:25-41. As discussed above, however, a POSITA would have
`
`recognized these advantages (transparency, knowledge sharing, and distributed
`
`processing) as well-known aspects of distributed computing by 2008-2009. See §I.
`
`
`3 A “POSITA” is a person of ordinary skill in the art at the time of the alleged
`
`invention of the challenged claims, as explained below. See infra §IV.
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000012
`
`

`

`
`
`16. The ’419 patent depicts the basic arrangement of its “dynamic
`
`distributed evaluator system 10” in FIG. 1 as nodes 20 in communication network
`
`12. Ex. 1001 (’419 patent), 2:1-
`
`4. The ’419 patent indicates
`
`evaluator 10 may run an
`
`application that “comprise[s] a
`
`number of operations that the
`
`nodes 20 may perform using code.” Ex. 1001 (’419 patent), 2:4-8. The evaluators
`
`46 in nodes 20 may send and receive instructions, locate and transmit code, and
`
`perform operations, where the instructions and code may be sent over network 12
`
`to the other nodes 20. Ex. 1001 (’419 patent), 2:8-12.
`
`17. The ’419 patent indicates that, where an application is distributed,
`
`multiple nodes 20 may perform related operations, but “[t]he distributed nature of
`
`the application may be transparent to a node 20 that calls for the performance of an
`
`operation” such that “node 20 may not know if the operation it called is being
`
`performed by another node 20.” Ex. 1001 (’419 patent), 2:34-40. Similarly, “an
`
`instruction requesting an operation may be sent without knowing the specific node
`
`20 that has the resources to perform the operation or how to reach that node 20.”
`
`Ex. 1001 (’419 patent), 2:41-44. Instead, “[t]he instruction may simply request a
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000013
`
`

`

`
`
`resource, and the evaluator 46 may then find the resource within the system.” Ex.
`
`1001 (’419 patent), 2:44-48.
`
`18. The ’419 patent’s FIG. 2
`
`depicts node 20 with interface 30,
`
`logic 32 with processor 42, and
`
`memory 34. Ex. 1001 (’419 patent),
`
`2:49-62. Logic 32 performs
`
`operations via instructions that include “an operation to perform, how to perform
`
`the operation, the code to use, how to get the code, how to format the result, what
`
`to do with the result, and/or a combination.” Ex. 1001 (’419 patent), 2:63-3:14.
`
`19. The ’419 patent’s FIG. 3
`
`depicts its method. Ex. 1001 (’419
`
`patent), 4:15-21. At 102, a node may be
`
`added to the network. Ex. 1001 (’419
`
`patent), 4:22-31. At 104, a first node
`
`may establish communication with a
`
`second node, such as through the
`
`network. Ex. 1001 (’419 patent), 4:32-
`
`35.
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000014
`
`

`

`
`
`20. At “108, the first node may tell the second node to perform an
`
`operation.” Ex. 1001 (’419 patent), 4:36-37. The instructions may be sent without
`
`the first node “knowing the code that will be required, when the code will be
`
`needed, or the identity of the node that will perform the operation.” Ex. 1001
`
`(’419 patent), 4:37-40. In other words, the ’419 patent indicates that the
`
`instructions of step 108 (and steps 112 and 116) themselves are not directed to a
`
`particular node in advance of the node performing the instructions, but are sent to
`
`the ’419 patent’s grid of nodes 20a-20n, which will determine which node actually
`
`performs the instructions of step 108 (and 112 and 116) as the “second node.”
`
`21. The ’419 patent indicates that instructions can be many different
`
`things, including “inputs, expected outputs, and/or aspect oriented features to
`
`control the execution and results on remote nodes.” Ex. 1001 (’419 patent), 4:43-
`
`45. The instructions can also be sent from the first node to multiple nodes (as
`
`discussed above), and may be related operations of a common application. Ex.
`
`1001 (’419 patent), 4:46-58.
`
`22. At 112, “[t]he first node may instruct the second node how to perform
`
`the operation using code[.]” Ex. 1001 (’419 patent), 4:59-60. Where the second
`
`node does not have the relevant code, “the first node may provide the code to the
`
`second node or tell the second node how to obtain the code,” such as from a third
`
`node storing the code. Ex. 1001 (’419 patent), 4:60-5:13. Nodes may also make
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000015
`
`

`

`
`
`local copies of retrieved code. Ex. 1001 (’419 patent), 5:14-23. Code may also be
`
`removed from a node after it is executed. Ex. 1001 (’419 patent), 5:24-41.
`
`Different code may be used on different nodes. Ex. 1001 (’419 patent), 5:65-6:11.
`
`23. At “116, the first node may instruct the second node what to do with
`
`the result of the operation.” Ex. 1001 (’419 patent), 6:35-36. Examples include
`
`“returning the result to the first node, sending the result to a third node, or using
`
`the result in another operation.” Ex. 1001 (’419 patent), 6:36-48.
`
`24. Thus, the specification of the ’419 patent appears to be directed to two
`
`main concepts: (i) obscuring which nodes are performing operations from the
`
`standpoint of a requesting node; and (ii) instructing a node framework to perform
`
`operations using code and returning the results. But, again, a POSITA would have
`
`understood these functions (transparency and distributed processing) to be well-
`
`known concepts of distributed computing systems by 2008-2009. See §I. The
`
`’419 patent provides no description of how its processes differ from these well-
`
`known techniques.
`
`B.
`Prosecution History
`25. The ’419 patent was filed as Application No. 12/497,323 on July 2,
`
`2009. Ex. 1002 (’419 patent FH), pp. 296-332. The as-filed application included
`
`independent application claims 1, 11, and 16 (corresponding to issued claims 1, 12,
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000016
`
`

`

`
`
`and 18 of the ’419 patent, respectively). Ex. 1002 (’419 patent FH), pp. 319-322.
`
`As a matter of example, originally filed claim 1 recited:
`
`
`
`26. The language of, for example, claim 1 is similar to the ’419 patent’s
`
`description of its alleged invention in the Summary of the Invention section
`
`discussed above (see ¶15, citing Ex. 1001 (’419 patent), 1:19-24) and thus reads on
`
`a normal one-to-one client/server process. Thus, the Examiner repeatedly rejected
`
`the original independent claims (and slightly amended versions) and the various
`
`dependent claims in view of various prior art teachings, including those of U.S.
`
`Patent No. 6,457,066 to Mein et al., U.S. Patent No. 6,321,274 to Shakib et al.,
`
`U.S. Patent Application Pub. No. 2004/0078486 to Salashoor, U.S. Patent
`
`Application Pub. No. 2005/0114534 to Lee, and U.S. Patent Application Pub. No.
`
`2009/0204694 to Kaneko.
`
`27. After several Office Actions, the Applicant added new application
`
`claims 18, 20, and 22 that specified that the telling and instructing steps involved a
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000017
`
`

`

`
`
`“plurality of nodes” (rather than just a “second node” as recited in, e.g., claim 1)
`
`and that the first node “does not know which one of the plurality of nodes will
`
`perform the operation.” Ex. 1002 (’419 patent FH), pp. 155-156. For example,
`
`new application claim 18 recited:
`
`28. Moreover, the Applicant argued that claims 18, 20, and 22 were
`
`allowable over Mein and Shakib because, in Applicant’s view, those references
`
`teach operation requests being sent directly to the server which performs the
`
`operation, rather than to a plurality, or framework or grid, of nodes. Ex. 1002
`
`(’419 patent FH), p. 161-162, reproduced in part below:
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000018
`
`

`

`
`
`
`
`29.
`
`In the next Office Action, the Examiner found each of the added
`
`claims 18, 20, and 22 to be allowable over the applied references if rewritten in
`
`independent form. Ex. 1002 (’419 patent FH), p. 118.
`
`30. Applicant thereafter added the features of application claims 18, 20,
`
`and 22 to respective independent application claims 1, 11, and 16 (corresponding
`
`to issued claims 1, 12, and 18 of the ’419 patent, respectively). Ex. 1002 (’419
`
`patent FH), pp. 83-89.
`
`31. However, the addition of the features by the Applicant resulted in
`
`redundant and inconsistent language. Thus, the Examiner proposed further
`
`substantive revisions in an interview (Ex. 1002 (’419 patent FH), p. 54) after which
`
`the ’419 patent was allowed (Ex. 1002 (’419 patent FH), pp. 37-53).
`
`32. However, this allowance was in error, as the features added to the
`
`claims to gain allowance – the telling and instructing elements being directed to a
`
`plurality of nodes and that the first node “does not know which one of the plurality
`
`of nodes will perform the operation” – were well-known to a POSITA by 2008-
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000019
`
`

`

`
`
`2009. As discussed above, the concepts of: (i) distribution transparency of nodes
`
`to a requesting node; and (ii) instructing a framework of nodes to perform
`
`operations using code and returning results, were well-known concepts of
`
`distributed computing systems by 2008-2009. See §I.
`
`C.
`Priority Date
`33. The ’419 patent was filed on July 2, 2009. It does not claim priority
`
`to any other U.S. or foreign Application. Nor am I aware of any evidence that the
`
`alleged inventions recited in the challenged claims were made earlier than July 2,
`
`2009.
`
`D. Challenged Claims
`34.
`I understand Petitioner is challenging the validity of claims 1-20 of
`
`the ’419 patent in the Petition for Inter Partes Review to which this declaration
`
`will be attached. Those claims are reproduced in Appendix 3. I have considered
`
`each of these claims, as well the ’419 patent prosecution history (Ex. 1002) and the
`
`other exhibits identified herein in forming my opinions.
`
`III. SUMMARY OF THE PRIOR ART
`35. There are a number of patents and publications that constitute prior art
`
`to the ’419 patent. I have reviewed and considered the prior art discussed in this
`
`section, along with the materials listed in Appendix 2.
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000020
`
`

`

`
`
`A.
`Invalidity Grounds
`36. Based on my review and analysis of the materials cited herein, my
`
`opinions regarding the understanding of a POSITA in the 2008-2009 timeframe,
`
`and my training and experience, it is my opinion that the challenged claims of the
`
`’419 patent are invalid based on the following grounds:
`
`Grounds
`
`Claims
`
`1
`
`2
`
`3
`
`1-4, 6-10,
`12, 13, 15,
`16, 18
`5, 11, 14,
`17, 19, 20
`5, 11, 14,
`17, 19, 20
`
`Statutory
`Basis
`Obviousness
`under §103
`
`Obviousness
`under §103
`Obviousness
`under §103
`
`Prior Art
`
`Verbeke
`
`Verbeke in view of Jalan
`
`Verbeke in view of Jalan and
`Neiman
`
`37.
`
`I understand that none of the references identified in the table above
`
`
`
`was cited or considered during prosecution of the ’419 patent. None of the
`
`references or any related patents are listed on the face of the ’419 patent. In
`
`addition, I reviewed the file history for the ’419 patent and am not aware of any of
`
`the above references being discussed in any office action or in the prosecution
`
`history generally.
`
`B.
`Verbeke (Exhibit 1004)
`38. Verbeke (Ex. 1004) is U.S. Patent Application Publication No.
`
`2004/0261069 to Verbeke. It was filed on June 20, 2003, and published on
`
`December 24, 2004.
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000021
`
`

`

`
`
`39.
`
`I understand that Verbeke is prior art under pre-AIA §102(b) because
`
`it is a publication of a U.S. patent application that was published more than one
`
`year before the earliest possible priority date of the ’419 patent (July 2, 2009).
`
`40.
`
`I have reviewed Verbeke. Verbeke is in the same field of endeavor as
`
`the ’419 patent (distributed computing). See infra §IV. Verbeke teaches4 a
`
`distributed computing system to run an application across multiple nodes. Ex.
`
`1004 (Verbeke), ¶[0016]. In Verbeke, the application is divided into N different
`
`code fragments (“tasks”) that are distributed across a plurality of worker nodes. Id.
`
`The worker nodes contain remote class loader mechanisms that locate and
`
`download classes needed for execution of the distributed code fragments. Id.; see
`
`also ¶¶[0066]-[0069].
`
`41. Exemplary embodiments of Verbeke’s distributed computing system
`
`are shown in, for example, its FIGS. 5 and 6, reproduced here.
`
`
`4 I use “teaches” herein to represent the broader concept of “teaches or suggests.”
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000022
`
`

`

`
`
`42. Verbeke teaches that a job submitter (e.g., job submitter node 1206 of
`
`FIG. 6) sends a message to a framework of nodes (e.g., including peer group 1200
`
`with worker nodes 1202a-1202h, task dispatcher peer group with task dispatcher
`
`nodes, and repository peer group of repository nodes) identifying a job to be
`
`performed, the code to be used, and how results are to be returned, where
`
`management of the job on the framework is by a task dispatcher node(s) (e.g., task
`
`dispatcher 1106 in FIG. 5 or a node in task dispatcher peer group in FIG. 6). Ex.
`
`1004 (Verbeke), ¶¶[0066]-[0076], [0079]-[0082], [0093], [0096]. In Verbeke, jobs
`
`are made up of common code for the job and individual tasks (code fragments) for
`
`particular nodes to run. Ex. 1004 (Verbeke), ¶[0073].
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000023
`
`

`

`
`
`43. To run a job, Verbeke teaches that its task dispatcher node(s) polls
`
`code repository node(s) (e.g., via repository manager 1108 in FIG. 5) to determine
`
`if the requested code is stored therein, and obtains it from job submitter node 1206
`
`if necessary. Ex. 1004 (Verbeke), ¶¶[0074]-[0075], [0096]. Repository manager
`
`1108 then creates a job repository for the requested job (e.g., job repositories
`
`1102a, 1102b, and 1102c in FIG. 5) on repository nodes. Id. Tasks may then be
`
`received from the job submitter and stored in the related job repositories (e.g.,
`
`tasks 1104a, 1104b, and 1104c). Ex. 1004 (Verbeke), ¶¶[0074]-[0075], [0096].
`
`44. The task dispatcher node(s) may then distribute tasks and code to
`
`worker nodes it has determined are available to perform the tasks. Ex. 1004
`
`(Verbeke), ¶¶[0076], [0096]. The worker nodes then execute the tasks and send
`
`them back with results to the task dispatcher node(s), which may then store the
`
`results in the relevant job repository in conjunction with the repository manager.
`
`Ex. 1004 (Verbeke), ¶¶[0079], [0096]. The results are then sent back to the job
`
`submitter pursuant to its instructions. Ex. 1004 (Verbeke), ¶[0082].
`
`45. Thus, Verbeke teaches a job submitter communicating with a
`
`framework of nodes (including worker nodes 1202a-1202h, task dispatcher nodes,
`
`and repository nodes), and telling the nodes to perform an operation (e.g., a task)
`
`using code (e.g., the code) and what to do with a result (e.g., return to the job
`
`submitter). Moreover, because the task dispatcher nodes, and not the job submitter
`
`
`
`
`
`
`
`
`
`
`
`
`Netflix, Inc. - Ex. 1003, Page 000024
`
`

`

`
`
`node, distributes the tasks to the worker nodes, the job submitter node does not
`
`know which worker nodes will perform the tasks it submits. Ex. 1004 (Verbeke),
`
`¶[0071]. These are all the alleged inventive features of the ’419 patent.
`
`Additionally, Verbeke is not cumulative to the references applied by the Examiner
`
`during pros