`
`UNITED STATES PATENT AND TRADEMARK OFFICE
`
`____________
`
`BEFORE THE PATENT TRIAL AND APPEAL BOARD
`
`____________
`
`APPLE INC., GOOGLE INC., and MOTOROLA MOBILITY LLC,
`
`
`
`Petitioners,
`
`v.
`
`Arendi S.A.R.L.,
`
`Patent Owner.
`
`____________
`
`Case No. IPR2014-00206 and IPR2014-00207
`
`Patent No. 7,496,854
`
`____________
`
`DECLARATION OF JOHN V. LEVY, Ph.D.
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`
`Arendi S.A.R.L. - Ex. 2003
`Page 1 of 101
`
`
`
`
`
`John V. Levy Declaration
`
`I, John V. Levy, make this declaration in connection with the proceedings
`
`identified above.
`
`INTRODUCTION
`
`1.
`
`I have been retained by counsel for Arendi S.A.R.L. (“Arendi”) as a
`
`technical expert in connection with the proceedings identified above. I submit this
`
`declaration on behalf of Arendi in the Inter Partes Reviews of United States Patent
`
`No. 7,496,854 (“the ‘854 patent”) in Case No. IPR2014-00207 and Case No.
`
`IPR2014-00206.
`
`
`
`2.
`
`I base my opinions below on my professional training and experience
`
`and my review of documents and materials produced in these Inter Partes reviews.
`
`My compensation for this assignment is $625 per hour. My compensation is not
`
`dependent on the substance of my opinions or my testimony or the outcome of the
`
`above-identified proceedings.
`
`
`
`QUALIFICATIONS
`
`3.
`
`I am the sole proprietor of John Levy Consulting, a consulting firm
`
`that specializes in consulting on managing development of high tech products,
`
`Arendi S.A.R.L. - Ex. 2003
`Page 2 of 101
`
`
`
`including computers and software. I have a Bachelor of Engineering Physics
`
`degree from Cornell University, a Master of Science degree in Electrical
`
`Engineering from California Institute of Technology, and a Ph.D. in Computer
`
`Science from Stanford University.
`
`4.
`
`From 1965 to 1966 at Caltech, my field of study was information
`
`processing systems. My coursework included systems programming, including the
`
`construction of compilers and assemblers. From 1966 to 1972, during my graduate
`
`study at Stanford, my field of study was computer architecture and operating
`
`systems. My coursework included computer systems design, programming and
`
`operating systems. During my employment at Stanford Linear Accelerator Center
`
`while I was a graduate student at Stanford University, I was a programmer and I
`
`participated in the design and implementation of a real-time operating system for
`
`use in data acquisition, storage and display. My Ph.D. thesis research related to
`
`computer systems organization and programming of multi-processor computers. I
`
`developed and measured the performance of several parallel programs on a
`
`simulated 16-processor system. I also studied file systems, disk and tape storage
`
`subsystems, and input/output.
`
`5.
`
`I have been an employee and a consultant for over thirty years in the
`
`computer systems, software and storage industry. After earning my doctorate from
`
`Stanford University in Computer Science, I worked as an engineer at a number of
`
`Arendi S.A.R.L. - Ex. 2003
`Page 3 of 101
`
`
`
`leading companies in the computer industry, including Digital Equipment
`
`Corporation, Tandem Computer, Inc., Apple Computer, Inc., and Quantum
`
`Corporation.
`
`6.
`
`From 1972 to 1974 at Digital Equipment Corporation I supervised the
`
`development of an input/output channel for high-speed mass storage (disk, drum
`
`and tape), and its implementation for 7 different peripheral units and 3 different
`
`computer systems. From 1974 to 1975 I was project engineer leading the
`
`development of a new computer system. From 1975 to 1976, I supervised an
`
`operating system development group. During this time, I reviewed design changes
`
`and bug reports and fixes for two operating systems. While working for Digital
`
`Equipment Corporation, I wrote a long-term strategic plan for input/output buses
`
`and controllers and operating systems, including the conversion of most I/O buses
`
`to serial implementations. I am the author of a chapter on computer bus design in
`
`the book Computer Engineering, published in 1978 by Digital Press.
`
`7.
`
`From 1977 to 1979 I was employed at Tandem Computer, Inc., where
`
`I worked on design of future multiprocessor systems. I also worked on problems
`
`related to distributed (networked) systems including rollback and recovery of
`
`distributed databases.
`
`8.
`
`From 1979 to 1982 I was employed at Apple Computer, Inc., where I
`
`worked on the design of a new computer system, the Lisa, which was a precursor
`
`Arendi S.A.R.L. - Ex. 2003
`Page 4 of 101
`
`
`
`to the Macintosh. I also supervised hardware and software engineers in the
`
`development of a new local area network.
`
`9.
`
`In 1980-81 I taught an upper-division course at San Francisco State
`
`University titled “Input/Output Architecture” which dealt with design of I/O
`
`channels, controllers, storage devices and their associated software.
`
`10. From 1982 to 1992 I consulted for a variety of client companies,
`
`including Apple Computer, Quantum Corporation and Ricoh Co., Ltd., on project
`
`management and product development. Consulting work for Quantum included
`
`working as a temporary supervisor of a firmware development team for a new hard
`
`disk drive. During this time I co-authored a paper, cited in my attached CV, on the
`
`design of a file system for write-once optical disk drives, related to work I did for
`
`client Ricoh.
`
`11. From 1993 to 1998 I was employed at Quantum Corporation, a
`
`manufacturer of hard disk drives, where I formed and managed a new group called
`
`Systems Engineering. While in this role I managed, among others, software and
`
`systems engineers who developed hard disk input/output drivers for personal
`
`computers and disk drive performance analysis and simulation software. While at
`
`Quantum, I also led the definition and implementation of high-speed improvements
`
`of the ATA disk interface standard, called Ultra-ATA/33 and /66, which also led to
`
`improvements in the SCSI interface standard. I was also involved in the design of
`
`Arendi S.A.R.L. - Ex. 2003
`Page 5 of 101
`
`
`
`file systems for hard disks, data compression schemes for disk data, and Ethernet-
`
`connected disk drives. I was Quantum’s representative to the Audio/Video
`
`Working Group of the 1394 (FireWire) Trade Association, a Consumer Electronics
`
`industry standards group, and participated in Quantum’s work in designing disks
`
`that could record and play back video and audio streams without needing an
`
`intervening computer system.
`
`12. My qualifications for forming the opinions set forth in this report are
`
`listed in this section and in Exhibit A attached, which is my curriculum vitae.
`
`Exhibit A also includes a list of my publications.
`
`13.
`
`I am a named inventor on seven United States patents, including
`
`several related to input/output buses and storage subsystems. I have been disclosed
`
`as an expert in over 50 cases and have testified at trial and in depositions. A list of
`
`my testimony is attached hereto as Exhibit B. I also have served as a technical
`
`advisor to two United States District Court Judges.
`
`14.
`
`I regularly teach courses such as “Computers – the Inside Story” and
`
`“The Digital Revolution in the Home” at the Fromm Institute for Lifelong
`
`Learning at the University of San Francisco.
`
`
`
`Arendi S.A.R.L. - Ex. 2003
`Page 6 of 101
`
`
`
`INFORMATION CONSIDERED IN FORMING OPINION
`
`15.
`
`I have reviewed the Inter Partes Pleadings for the above referenced
`
`proceedings including ‘854 Patent, U.S. Patent No. 6,085,206 (“Domini ‘206”)
`
`and U.S. Patent No. 6,377,965 (“Hachamovitch ‘965”). I have relied on my own
`
`knowledge and experience as well as published documents in forming my
`
`opinions. A list of materials I relied upon in arriving at my opinions is attached as
`
`Exhibit C.
`
`16.
`
`In my opinion, a person of ordinary skill in the art pertaining to the
`
`'854 patent at the relevant date discussed below would have at least a Bachelor’s
`
`degree in Computer Science or Electrical Engineering or related discipline and
`
`approximately two years of experience designing user applications or software
`
`modules.
`
`TECHNOLOGY BACKGROUND
`
`17. To understand operation of the Domini program module and of the
`
`Hachamovitch program module in relation to a word processing application
`
`program with which each module communicates, it is valuable to distinguish
`
`between two types of communication. In computer systems generally, there are
`
`two major classifications of ways to communicate between programs or program
`
`modules: synchronously and asynchronously. Asynchronous communications are
`
`more complex, because they allow one program to continue running after it has
`
`Arendi S.A.R.L. - Ex. 2003
`Page 7 of 101
`
`
`
`sent a message or signal to another program. The sending program does not wait
`
`for an acknowledgement or reply from the receiving program before continuing
`
`with its processing. Examples of asynchronous communication between programs
`
`include input/output requests sent to a file system or a file server. As long as the
`
`program making the request does not need to wait for input, the program can
`
`specify its input or output operation and data, and then continue with its
`
`processing. Synchronous communications (sometimes also called “blocking”
`
`communications) are used whenever the sending program must wait for a response
`
`from the receiving program (including possibly an acknowledgement that the
`
`message has been
`
`received).
`
` Examples of blocking or synchronous
`
`communications include requesting (and waiting for) user input from a keyboard or
`
`mouse.
`
`18.
`
`In the following, I use the term “subsidiary module” to refer to a
`
`program module that is activated only when it is called by another program. A
`
`subsidiary module is not independently executable. When an application program
`
`makes a call to a subsidiary module, communication is also typically done
`
`synchronously, because the call is made to obtain data or a specific result from the
`
`subsidiary module. Because the application program cannot proceed before
`
`receiving the requested data, the application program must be “blocked” or wait for
`
`the subsidiary module to respond.
`
`Arendi S.A.R.L. - Ex. 2003
`Page 8 of 101
`
`
`
`19. The spell-checking and grammar-checking program modules of
`
`Domini and the word-completion program module of Hachamovitch are modules
`
`that receive requests from an application program (the word processing program)
`
`and respond with specific information that the application program needs before it
`
`can proceed. Whether the modules are implemented as subroutines within the
`
`same program unit as the application program or are implemented as callable
`
`utilities on the same or a different computer system, the interaction between the
`
`application program and the module will be synchronous, because the application
`
`program must wait for the information contained in the response from the module.
`
`Whether they are subroutines or callable utility programs, the modules would not
`
`be viewed by a person of ordinary skill in the art as independently executable
`
`programs or application programs, because they are activated only by calls from
`
`the word processor application program.
`
`THE DOMINI SYSTEM
`
`20. With this distinction as background, I now turn to discussion of the
`
`operation of Domini’s system. Figures 5, 6 and 7 of Domini show the operation of
`
`the grammar checker and the spell checker program modules in the Domini
`
`system. Figure 6 portrays the details of box 510 (Extract Sentence from
`
`Document) of Fig. 5. The four steps of Fig. 6 show that an application program
`
`(the word processing program) calls the grammar checker to extract a sentence
`
`Arendi S.A.R.L. - Ex. 2003
`Page 9 of 101
`
`
`
`from a text buffer. Because Fig. 6 shows “call grammar checker” 605 as the first
`
`step and “receive sentence indices from grammar checker” 620 as the fourth and
`
`last step of “extract sentence from document” 510, we know that the calling
`
`program (the word processor) waits for the completion of step 620 before
`
`continuing with step 515 “spell check sentence”. Similarly, “spell check sentence”
`
`515 is elaborated in Fig. 7 with steps 705 through 750. The sequence begins with
`
`“call spell checker” 705 followed by “send word to spell checker” 710. Step 715,
`
`“verify accuracy of word” is then performed by the spell checker, followed by step
`
`720, “send spelling data to application.” This makes it clear that the calling
`
`program (the word processor) waits for the results of the spell checking operation.
`
`The steps for spell checking are performed iteratively for each word in the sentence
`
`until the test “another word?” 750 results in a “no” and the application program
`
`continues to step 517. In addition, if any word is found in step 725 “word
`
`satisfactory?” to be not satisfactory, the application program receives from the
`
`spell checker error type information at step 730 and suggestions at step 735. The
`
`application program waited for this information from the spell checker because it
`
`cannot proceed without it. The application program receives error type and
`
`suggestion information from the spell checker, and then interacts with the user in
`
`steps 740 “display combined dialogue” and 745 “receive command input from
`
`user.” Like the application program to grammar checker interactions described
`
`Arendi S.A.R.L. - Ex. 2003
`Page 10 of 101
`
`
`
`above, these interactions are synchronous, because the application program cannot
`
`proceed until a response is received from the user input/output subsystem. These
`
`steps 740 and 745 are performed by the application program (the word processor),
`
`not by the spell checker. The spell checker provides text for the application
`
`program to use in displaying options to the user and later for inserting into the open
`
`document. However, the application program itself performs the insertion, based
`
`on the text supplied by the spell checker.
`
`21. The Specification of Domini explains how the word processor
`
`application receives information from the spell checker program module:
`
`At step 730, the preferred application program module consults a structure
`
`called a Spell Check Return Status field(cid:1)in a Spell Return Buffer (SRB) to
`
`determine the type of spelling error. When the CSAPI function SpellCheck
`
`is called, the spell checker program module returns the SRB. The SRB
`
`includes a field called a Spell Check Return Status (SCRS). The SCRS is an
`
`integer code that the application program module consults to determine the
`
`error type information. The error type information indicates the type of
`
`spelling error detected by the spell checker program module.
`
`(Domini Col. 17 ll. 58-67)
`
`Arendi S.A.R.L. - Ex. 2003
`Page 11 of 101
`
`
`
`Based on this description together with Fig. 7 and the sequence of operations
`
`explained above in ¶20, a person of ordinary skill in the art would understand that,
`
`in the Domini system, all interactions between the word processor and the spell
`
`checker program module are synchronous communications. Similarly, as detailed
`
`in Figs. 6 and 8 of Domini, sentence-breaking and grammar checking are also
`
`performed using synchronous communications between the word processor and the
`
`grammar checker program module.
`
`22. A functionality that is key to the operation of the Domini spell
`
`checker utility and to the Hachamovitch word completion utility is the ability to
`
`cause insertion of text into a document that is concurrently being operated on by a
`
`word processor application program. This functionality enables the Domini spell
`
`checker program module, operating in conjunction with the word processor
`
`application, to insert a correctly spelled word into the document. This functionality
`
`similarly enables the Hachamovitch word completion program module (in
`
`cooperation with the application program, as described above) to insert into a word
`
`processor document, text that is associated with a user-definable pattern of
`
`keystrokes. Because in each case this insertion functionality sheds light on the
`
`nature of operation of the utility, I discuss the insertion functionality in relation to
`
`the manner of operation of the Domini and Hachamovitch program modules.
`
`Arendi S.A.R.L. - Ex. 2003
`Page 12 of 101
`
`
`
`23.
`
`I have discussed above the preferred grammar checker program
`
`module and the preferred spell checker program module of Domini. In contrast to
`
`these modules, the background section of Domini (at Col. 1 ll. 56-66) refers to
`
`prior art standalone spell checker program modules:
`
`Spell checker program modules and grammar checker program modules were
`
`‘stand-alone’ products when they were initially introduced to personal computer
`
`users. In other words, spell checker program modules or grammar checker
`
`program modules were separate program modules from each other and from the
`
`word processor program module. These "stand-alone" program modules would
`
`scan documents of various formats, present errors, and suggest corrections,
`
`usually through a user interface, or dialog box. Later, the spell checker and
`
`grammar checker became integrated with word processor program modules.
`
`(Domini ‘206 Col. 1 ll. 56-66)
`
`24. A person of ordinary skill in the art would understand that a
`
`“standalone spell checker” was an independently executable computer program
`
`that does not interact with a word processor program in order to perform its spell
`
`checking function. Such a spell checker, being independently executable, would
`
`generate and output its own user display and receive inputs directly from the user.
`
`The separate user interfaces of such programs is cited by Domini as a disadvantage
`
`of performing spell checking using a “stand-alone” spell checker. (See Domini
`
`Arendi S.A.R.L. - Ex. 2003
`Page 13 of 101
`
`
`
`‘206, Col. 1 l. 56 – Col. 2 l. 26). The standalone spell checker would also receive
`
`input from and perform output to a text file without reference to a word processor
`
`program.
`
`25. Thus, such a standalone spell checker program module would not be
`
`capable of inserting a correctly spelled word into a document concurrently being
`
`viewed and operated on in a word processor application program, because it would
`
`not have access to the word processor application’s document. In consequence of
`
`this fact, Domini does not teach or suggest how a standalone spell checker would
`
`achieve insertion of a word into a document within a word processor.
`
`26. Domini states in the background that as spell checkers developed,
`
`they were integrated into the word processor. A person of ordinary skill in the art
`
`would understand “integrated” to mean that the spell checker operated within the
`
`process of the word processor and synchronously with the word processor in order
`
`to achieve insertion. Even in the postulated case of a spell checker executing in
`
`another processor connected by a network to the processor executing the word
`
`processor, such a spell checker would nonetheless be invoked using synchronous
`
`communications and therefore would still be a subsidiary program activated by
`
`calls from the word processor.
`
`Arendi S.A.R.L. - Ex. 2003
`Page 14 of 101
`
`
`
`THE HACHAMOVITCH SYSTEM
`
`27. Hachamovitch ‘965 [Ex. 1008] is concerned with an “auto-complete”
`
`utility that operates in conjunction with an application program such as a word
`
`processor. The interactions between the application program (such as a word
`
`processor) and the auto-complete utility are detailed in Fig. 5 and at Col. 14 l. 18
`
`through Col. 16 l. 7 of the Hachamovitch specification. I will first review steps of
`
`this Fig. 5 flowchart to provide an overview of the action of the word-completion
`
`utility.
`
`28.
`
`In steps 501 and 502, the utility first removes a displayed completion
`
`entry (box) if one is currently displayed. The utility then waits for a character (a
`
`keystroke) to be received into the current file. It then at 504 asks whether the
`
`required minimum number of characters have been entered since the last delimiter
`
`(usually a space). If so, it goes on at 506 to compare the current text string with
`
`name entries of “completion pairs” in a suggestion list. If, at step 508, the text
`
`matches a name entry, it continues to 510, where it asks whether the number of
`
`completion characters meet another criterion. If so, it checks at 512 that the
`
`entered text matches the “context” (usually a selected completion pair list) and
`
`capitalization required to make the completion text likely to be correct. If so, then
`
`the completion text is displayed in the “word completion field” (the text box shown
`
`in Figs. 2A, 2B and 2C). The utility then waits for a keystroke input from the user
`
`Arendi S.A.R.L. - Ex. 2003
`Page 15 of 101
`
`
`
`and determines at 516 whether that keystroke represents the “completion
`
`command” (i.e., acceptance of the word completion by the user typing the “tab” or
`
`“enter” key). If so, then at 518 the utility “replaces the current data with the
`
`completion entry from the corresponding name-completion pair.” (Hachamovitch
`
`‘965 at Col. 15 ll. 65-66) This is where the utility achieves the insertion of the
`
`completion text into the “current file.” The utility finishes by applying an “ending
`
`space management” procedure 520 and then goes back to step 502, where the
`
`completion text is removed from the screen. If any of the above tests (at 504, 508,
`
`510, 512, or 516) fails (“NO”), then the utility continues at step 501.
`
`29. A person of ordinary skill in the art would understand that the
`
`operation described above requires the application program and the word-
`
`completion utility to be tightly connected and cooperative. By “tightly connected,”
`
`I mean that the utility program module (Hachamovitch) has access to data
`
`structures (buffers) in the application program that contain the user input
`
`keystrokes and the text of the document being viewed in the application program,
`
`as well as access to the display buffer from which user output is being generated.
`
`In addition, the utility is called by the application program every time there is a
`
`keystroke input to the user input buffer. Without such a call, the utility would be
`
`unable to count and examine each keystroke as it is input, such as at steps 504 and
`
`516. The utility is also cooperative, in the sense that the application program is
`
`Arendi S.A.R.L. - Ex. 2003
`Page 16 of 101
`
`
`
`depending on the word completion utility to update the completion text box at the
`
`appropriate location on the user’s screen. Thus, even though it may be linked via a
`
`standard interface or API, the word-completion utility is operating synchronously
`
`as an integral part of the application program.
`
`30. Hachamovitch mentions that the word completion utility may be an
`
`“application independent” utility.
`
`… [T]he word completion system may be deployed within an operating system
`
`or as a stand-alone utility that may operate on an application-independent basis.
`
`Application independence is the ability of the same word completion system to
`
`work with several different application programs, such as a word processing
`
`program, an e-mail program, a spreadsheet program, a personal calendar
`
`program, and so forth.
`
`(Hachamovitch ‘965 Col. 7 l. 65 – Col. 8 l. 5)
`
`A person of ordinary skill in the art would understand that “application
`
`independent” in this paragraph of Hachamovitch refers to the utility having a
`
`standard interface (as in Domini’s CSAPI and CGAPI) that can be used by any one
`
`of multiple application programs and being capable of running within and
`
`synchronously with any one of a plurality of application programs.
`
`31. Hachamovitch states that an interface exists within each application
`
`program that operates with the Hachamovitch utility:
`
`Arendi S.A.R.L. - Ex. 2003
`Page 17 of 101
`
`
`
`To deploy the word completion system as an application-independent
`
`utility, an interface is defined within each application program through
`
`which the word completion utility may communicate with each application
`
`program. This allows the word completion utility to monitor the entry of
`
`characters into the application program user interface, to determine the
`
`location within the user interface to display the word completion frame, and
`
`to determine when the user had invoked the word completion user interface.
`
`The only potential drawback of an application-independent deployment
`
`may be a slight reduction in the speed at which the word completion system
`
`performs its operations. (Hachamovitch ‘965 Col. 8, ll. 6-17)
`
`A person of ordinary skill in the art would understand from reading this description
`
`and from reviewing Hachamovitch Fig. 5 that the word completion utility inspects
`
`each keystroke input by the user to the active file of the word processing or other
`
`application program. (See “Receive a character into the current file” 503.) A
`
`person of ordinary skill in the art would also understand that the word completion
`
`utility outputs suggestions into a defined text box on the user’s screen. (See, e.g.,
`
`Fig. 2A, box 208; Fig. 2B, box 208’; Fig. 2C, box 208’’. See also Fig. 5, “Display
`
`completion in the word completion field” 514.)
`
`32.
`
`In
`
`the paragraph referring
`
`to
`
`the utility as an “application
`
`independent” utility, (Col. 7 l. 66 – Col. 8 l. 5) Hachamovitch does not explain
`
`Arendi S.A.R.L. - Ex. 2003
`Page 18 of 101
`
`
`
`how insertion would be achieved if the utility and the application program were not
`
`tightly integrated and cooperative, and therefore a person of ordinary skill in the art
`
`would conclude that the utility operates synchronously and cooperatively as part of
`
`the application program to manage text in the application program’s text buffer as
`
`taught by the main embodiment.
`
`33. Hachamovitch mentions that an alternative embodiment of the word
`
`completion utility could be “deployed within an operating system.” (Col. 7 ll. 65-
`
`67) Hachamovitch does not describe this embodiment and does not describe how
`
`it would achieve insertion of a selected word completion within a word processing
`
`document of a first application program. Insertion of text in Hachamovitch is only
`
`described with respect to the preferred embodiment, and in that embodiment
`
`insertion is achieved by invoking the utility synchronously and cooperatively as
`
`described above.
`
`34.
`
`If the word completion utility were to be an independently executable
`
`application program, a person of ordinary skill in the art would need a detailed
`
`description as to how the word completion utility would interact with the main
`
`application program to achieve insertion. Hachamovitch does not provide such a
`
`disclosure.
`
`35. For a separate application program, such as a stand-alone spell
`
`checker or word-completion utility, to accomplish analysis of typed text and
`
`Arendi S.A.R.L. - Ex. 2003
`Page 19 of 101
`
`
`
`insertion of new text into a word processing document within a word processor, a
`
`person of ordinary skill in the art would understand that all of the following data
`
`structures and program interactions would be required:
`
`a. a compatible user interface so that the inserting program would
`
`know what to display to the user
`
`b. a buffer for receiving text input by the user, and the ability to
`
`output text of a different length from the input text
`
`c. once the text has been analyzed, the ability to output text or menus
`
`to the user’s display, and to input or receive a selection made by
`
`the user
`
`d. if text in the currently-displayed word processor document is to be
`
`changed or added-to, a means for determining the position in the
`
`document where the text is to be inserted
`
`e. formatting of the text to be inserted and awareness of changes to
`
`the formatting of other surrounding words that may be required.
`
`f. The ability to interrupt the word processing process to prevent
`
`errors during the insertion.
`
`Since these data structures and program interactions are not taught by
`
`Hachamovitch or Domini, a person of ordinary skill in the art would not be able to
`
`implement operation of the Hachamovitch utility’s functionality based on the
`
`Arendi S.A.R.L. - Ex. 2003
`Page 20 of 101
`
`
`
`disclosure in Hachamovitch or implement operation of the Domini spell checker
`
`module functionality based on the disclosure of Domini, unless the functionality
`
`were implemented as a subsidiary program that is not independently executable.
`
`36.
`
`In fact, neither Domini nor Hachamovitch teach or suggest enabling a
`
`first application program to insert content into a document concurrently accessible
`
`from within a second application program.
`
`
`
`THE ‘854 PATENT
`
`37.
`
`It is readily apparent in reading the claims of the ‘854 patent that a
`
`key aspect of the invention lies in the interactions between a first application
`
`program and a second application program (see, e.g., ‘854 Patent Claims 1, 3, 4,
`
`57, 64, 65). In particular, first information in the first application program is
`
`associated with second information by means of a mechanism (such as a database
`
`lookup) implemented in the second application program. Subsequently, the second
`
`information obtained by means of the second application program is typically
`
`inserted into a document within the first application program.
`
`38. The ‘854 patent describes inserting such second information into a
`
`document:
`
`If the program finds name(s) and address(es) corresponding to the part of
`
`the addressee’s name typed, this additional information is automatically
`
`Arendi S.A.R.L. - Ex. 2003
`Page 21 of 101
`
`
`
`entered into the user’s word processor, optionally with a confirmation from
`
`the user that this is the correct data.”
`
`(‘854 Patent Col. 3 ll. 63-67)
`
`This action of inserting is also shown at steps 18, 20 and 22 in Fig. 1 and steps 18,
`
`20, 21 and 22 in Fig. 2. (See also Col. 4 ll. 46-54 and Col. 5 ll. 11-22)
`
`39.
`
`In the Summary of the Invention section of the ‘854 Patent, the
`
`inventor describes in general terms how the objects of the invention are achieved:
`
`… providing a function item, such as a key, button, icon, or menu, tied to a
`
`user operation in a computer, whereby a single click on the function item in
`
`a window or program on a computer screen, or one single selection in a
`
`menu in a program, initiates retrieval of name and addresses and/or other
`
`person or company related information, while the user works
`
`simultaneously in another program, e.g., a word processor. The click on the
`
`function item initiates a program connected to the button to search a
`
`database or file available on or through the computer ….
`
`(‘854 Patent, Col. 2 ll. 16-25, emphasis added)
`
`A person of ordinary skill in the art reading this portion of the ‘854 Specification
`
`would understand that a common way for “[t]he click on the function item [to]
`
`initiate[] a program connected to the button ….” is by means of a script or a macro
`
`that runs within the word processor application program or by similar functionality
`
`Arendi S.A.R.L. - Ex. 2003
`Page 22 of 101
`
`
`
`programmed directly into the word processor source code. Selecting the button
`
`invokes the functionality, and the script or macro or source code then activates the
`
`second application program to “initiate[] retrieval” of information from a database.
`
`40. The retrieval of second information using the second application
`
`program occurs “while the user works simultaneously” in the word processor.
`
`Thus, a person of ordinary skill in the art understands that the two application
`
`programs are executing independently.
`
`41.
`
`In order to insert words into a document open inside of a word
`
`processor application program, a program module that accesses information to be
`
`inserted into the document must be running inside the word processor. Thus, a
`
`person of skill in the art would understand that there is also a script or macro
`
`running in the word processor that performs the insertion into the open document.
`
`APPLICATION PROGRAMS
`
`42. An application program is generally understood to be a program with
`
`a user interface running in a process under the control of an operating system. An
`
`application program calls upon services of the operating system to achieve
`
`functions such as input/output, scheduling of its own operation (such as suspending
`
`itself while waiting for an event to happen), allocation of main memory space, and
`
`invocation of another program in a separat
Accessing this document will incur an additional charge of $.
After purchase, you can access this document again without charge.
Accept $ Charge
Still Working On It
This document is taking longer than usual to download. This can happen if we need to contact the court directly to obtain the document and their servers are running slowly.
Give it another minute or two to complete, and then try the refresh button.
A few More Minutes ... Still Working
It can take up to 5 minutes for us to download a document if the court servers are running slowly.
Thank you for your continued patience.
This document could not be displayed.
We could not find this document within its docket. Please go back to the docket page and check the link. If that does not work, go back to the docket and refresh it to pull the newest information.
Your account does not support viewing this document.
You need a Paid Account to view this document. Click here to change your account type.
Your account does not support viewing this document.
Set your membership
status to view this document.
With a Docket Alarm membership, you'll
get a whole lot more, including:
- Up-to-date information for this case.
- Email alerts whenever there is an update.
- Full text search for other cases.
- Get email alerts whenever a new case matches your search.
One Moment Please
The filing “” is large (MB) and is being downloaded.
Please refresh this page in a few minutes to see if the filing has been downloaded. The filing will also be emailed to you when the download completes.
Your document is on its way!
If you do not receive the document in five minutes, contact support at support@docketalarm.com.
Sealed Document
We are unable to display this document, it may be under a court ordered seal.
If you have proper credentials to access the file, you may proceed directly to the court's system using your government issued username and password.
Access Government Site
