Patent US5758160A successfully refreshed from Google Patents.
US5758160A
Expired / Lapsed
US
⏱️ 0.0 years remaining
Method and apparatus for building a software program using dependencies derived from software component interfaces
Assignee: Apple Inc
•
Filing: 1993-06-28
•
Granted: 1998-05-26
•
Expires: 2013-06-28
Abstract
Abstract A human oriented object programming system provides an interactive and dynamic process for the incremental building of computer programs which facilitates the development of complex computer programs such as operating systems and large applications with graphic user interfaces (GUIs). The program is modeled as a collection of units called components. A component represents a single compilable language element such as a class or a function. The three major functionality are the database, the compiler and the build mechanism. The database stores the components and properties. The compiler, along with compiling the source code of a property, is responsible for calculating the dependencies associated with a component. The build mechanism uses properties of components along with the compiler generated dependencies to correctly and efficiently sequence the compilation of components during a build process.
Inventors
- 👤 Peter Joseph McInerney
- 👤 Bill Gibbons
Bibliographic Details
Application Number
—
Jurisdiction
US
Data Source
google_patents
Last Synchronized
2026-10-29 05:40
CPC Classifications
G; G06; G06F; G06F8/00; G06F8/40; G06F8/41; G06F8/48; G06F8/70; G06F8/71
Claims Analysis
Total Claims: 38
Claim 1
Independent Claim
107 words
A method for building a computer program after changes are made to the program, comprising the steps of: (a) modeling a computer program as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces; (b) storing the components in a memory; (c) accessing the stored components and calculating dependencies associated with each component to develop a list of dependencies; (d) compiling each component whose implementation was changed: and (e) for each component whose interface was changed, compiling components based on the list of dependencies for that component to build the computer program.
Claim 2
Independent Claim
107 words
A method for building a computer program after changes are made to the program, comprising the steps of: (a) modeling a computer program as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces; (b) storing the components in a memory; (c) accessing the stored components and calculating dependencies associated with each component to develop a list of dependencies; (d) compiling each component whose implementation was changed: and (e) for each component whose interface was changed, compiling components based on the list of dependencies for that component to build the computer program.
Claim 3
Dependent Claim
31 words
The method as recited in claim 1, including the steps of: (a) editing to create, change or delete a component; and (b) storing editing changes of components in a change list.
Claim 4
Dependent Claim
27 words
The method as recited in claim 2, wherein the components have a BuildState value indicative of a component's status based on editing changes in the change list.
Claim 5
Dependent Claim
23 words
The method as recited in claim 3, including the step of processing the change list to determine possible components of a build operation.
Claim 6
Dependent Claim
55 words
The method as recited in claim 4, including the step of storing each change list item in a compile list and processing the change list items as the change list items are added to the compile list to identify components that depend on the changed components and add the dependent components to the compile list.
Claim 7
Dependent Claim
20 words
The method as recited in claim 5, including the step of adding the dependent components with a value of Uncertain.
Claim 8
Dependent Claim
20 words
The method as recited in claim 5, including the step of recursively processing each item added to the compile list.
Claim 9
Dependent Claim
31 words
The method as recited in claim 1, wherein the step of compiling is performed by compiling the components referenced in the InterfaceCompileList first before compiling the components referenced in the ImplementationCompileList.
Claim 10
Dependent Claim
70 words
The method as recited in claim 8, wherein components have BuildState values, the BuildState values on the InterfaceCompileList including BeingCompiled, NeedToCompile or Uncertain, including for each reference on the InterfaceCompileList the steps of: if the BuildState value is BeingCompiled or NeedToCompile, setting the BuildState to BeingCompiled and then compiling the component; but if the BuildState value is Uncertain, setting the BuildState value to BeingCompiled and then conditionally compiling the component.
Claim 11
Dependent Claim
34 words
The method as recited in claim 9, wherein if the compiler successfully compiles the component, then performing the step of setting the BuildState value of the component to Compiled before processing a next component.
Claim 12
Dependent Claim
21 words
The method as recited in claim 9, wherein if the compiler returns a value of Abort, then processing a next component.
Claim 13
Dependent Claim
48 words
The method as recited in claim 11, wherein if the compiler returns a value of Error in the step of compiling, then setting the BuildState value of the component to CompileError and adding a reference to an error list in said project component before processing a next component.
Claim 14
Dependent Claim
46 words
The method of building a computer program according to claim 11, wherein if the compiler returns a value Error, then setting the BuildState value of the component to UncertainError and adding a reference to an error list in said project component before processing a next component.
Claim 15
Dependent Claim
108 words
The method of building a computer program according to claim 11, wherein if the compiler compiles the component, then performing the step of setting the BuildState value of the component to Compiled before processing a next component, but if the compiler returns a value of Abort, then setting the BuildState value of the component to CompileError and adding a reference to an error list in said project component before processing the next component, but if the compiler returns a value Error, then setting the BuildState value of the component to UncertainError and adding a reference to an error list in said project component before processing the next component.
Claim 16
Dependent Claim
64 words
The method as recited in claim 11, wherein the BuildState values on the ImplementationCompileList include NeedToCompile or Uncertain, including for each reference on the ImplementationCompileList the steps of: (a) if the BuildState value is NeedToCompile, setting the BuildState to BeingCompiled and then compiling the component; and (b) if the BuildState value is Uncertain, setting the BuildState value to Compiled before processing a next component.
Claim 17
Dependent Claim
44 words
The method of building a computer program according to claim 13 wherein if the compiler successfully compiles the component in said step of compiling, then further performing the step of setting the BuildState value of the component to Compiled before processing the next component.
Claim 18
Dependent Claim
52 words
The method of building a computer program according to claim 13, wherein if the compiler returns a value of Error in the step of compiling, then setting the BuildState value of the component to CompileError and adding a reference to an error list in said project component before processing the next component.
Claim 19
Dependent Claim
80 words
The method of building a computer program according to claim 13, wherein if the compiler successfully compiles the component, then further performing the step of setting the BuildState value of the component to Compiled before processing the next component, but if the compiler returns a value of Error in the step of compiling, then setting the BuildState value of the component to CompileError and adding a reference to an error list in said project component before processing the next component.
Claim 20
Dependent Claim
58 words
The method as recited in claim 13, wherein for each component in said change list, if the Interface part has been changed, the component is added to the InterfaceCompileList, if the Implementation part has been changed and the change can affect other components, the component is added to the InterfaceCompileList, otherwise, the component is added to the ImplementationCompileList.
Claim 21
Dependent Claim
40 words
The method of building a computer program according to claim 18, wherein if the compiler successfully compiles the reference in either of said steps of compiling or conditionally compiling, then processing a next reference until all references have been processed.
Claim 22
Independent Claim
147 words
A method for building a computer program after changes are made to the program, comprising the steps of: (a) generating a computer program as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces; (b) storing the components in a memory; (c) accessing the stored components and calculating dependencies associated with each component to develop a list of dependencies; (d) compiling each component whose implementation was changed; (e) for each component for which a dependency on the interface of a second component was detected during compilation in step (d), querying a database of declarations to retrieve a processed form of an interface for the second component; (f) using the processed form of the second component interface for the dependency when compilation is continued; and (g) determining the status of the component's declaration.
Claim 23
Independent Claim
147 words
A method for building a computer program after changes are made to the program, comprising the steps of: (a) generating a computer program as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces; (b) storing the components in a memory; (c) accessing the stored components and calculating dependencies associated with each component to develop a list of dependencies; (d) compiling each component whose implementation was changed; (e) for each component for which a dependency on the interface of a second component was detected during compilation in step (d), querying a database of declarations to retrieve a processed form of an interface for the second component; (f) using the processed form of the second component interface for the dependency when compilation is continued; and (g) determining the status of the component's declaration.
Claim 24
Dependent Claim
31 words
The method as recited in claim 21, including the step of continuing with the compilation using the status of the component's declaration if the status is indicative of a compiled state.
Claim 25
Dependent Claim
36 words
The method as recited in claim 22, including the step of returning an error value and stopping processing of the current component status of the component's declaration if the status is indicative of an error state.
Claim 26
Dependent Claim
36 words
The method as recited in claim 21, including the step of returning an abort value and stopping processing of the current component status of the component's declaration if the status is indicative of an abort state.
Claim 27
Dependent Claim
57 words
The method as recited in claim 21, wherein the step of querying a database of declarations to determine the at least one name of a component's declaration, includes the steps of: (a) determining if the status of the component is compiled, and (b) returning the compiled declaration and an associated compile status if the status is compiled.
Claim 28
Dependent Claim
22 words
The method as recited in claim 25, including returning a compile status of error if the compile status is declared in error.
Claim 29
Dependent Claim
41 words
The method as recited in claim 21, including the steps of: (a) determining if the status of the component is uncertain or needtocompile; and (b) storing the component as a first item on a compile list; and returning an abort status.
Claim 30
Independent Claim
115 words
A system for building a computer program after changes are made to the program, comprising: (a) means for modeling a computer program as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces; (b) means for storing the components in a memory; (c) means for accessing the stored components and calculating dependencies associated with each component to develop a list of dependencies; and (d) means for compiling each component whose implementation was changed; (e) means responsive to each component whose interface was changed, for compiling components based on the list of dependencies for that component to build the computer program.
Claim 31
Independent Claim
115 words
A system for building a computer program after changes are made to the program, comprising: (a) means for modeling a computer program as a collection of components with dependencies between components, each component having an interface and an implementation and wherein all component dependencies are from component interfaces; (b) means for storing the components in a memory; (c) means for accessing the stored components and calculating dependencies associated with each component to develop a list of dependencies; and (d) means for compiling each component whose implementation was changed; (e) means responsive to each component whose interface was changed, for compiling components based on the list of dependencies for that component to build the computer program.
Claim 32
Dependent Claim
32 words
The system as recited in claim 28, including: (a) means for editing to create, change or delete a component; and (b) means for storing editing changes of components in a change list.
Claim 33
Dependent Claim
27 words
The system as recited in claim 29, wherein the components have a BuildState value indicative of a component's status based on editing changes in the change list.
Claim 34
Dependent Claim
22 words
The system as recited in claim 30, including means for processing the change list to determine possible components of a build operation.
Claim 35
Dependent Claim
54 words
The system as recited in claim 31, including means for storing each change list item in a compile list and processing the change list items as the change list items are added to the compile list to identify components that depend on the changed components and adding the dependent components to the compile list.
Claim 36
Dependent Claim
19 words
The system as recited in claim 32, including means for adding the dependent components with a value of Uncertain.
Claim 37
Dependent Claim
19 words
The system as recited in claim 32, including means for recursively processing each item added to the compile list.
Claim 38
Dependent Claim
68 words
The system as recited in claim 28, wherein each component is composed of a set of properties which are divided into a public part called an Interface and a private part called an Implementation, dependencies of components being related only to the Interface part, and maintaining a dependency list is performed by maintaining an InterfaceCompileList and an ImplementationCompileList, respectively, for the public and private parts of the components.
References Cited (Backward Citations)
US4589068A
Cited
US4943932A
Cited
US4809170A
Cited
US4910663A
Cited
US4953084A
Cited
US5129086A
Cited
US5193190A
Cited
US5170465A
Cited
US5182806A
Cited
US5193191A
Cited
US5201050A
Cited
US5325531A
Cited
US5124989A
Cited
US5204960A
Cited
US5140671A
Cited
US5175856A
Cited
US5187789A
Cited
US5325533A
Cited
US5519866A
Cited
USPTO Annuity & Maintenance Windows
| Annuity Stage | Window Opens | Payment Deadline | Surcharge Period Until | Estimated Fee | Status |
|---|---|---|---|---|---|
| 3.5 Years (Year 4) | 2001-05-25 | 2001-11-24 | 2002-05-26 | $2000.00 | Window Closed / Lapsed |
| 7.5 Years (Year 8) | 2005-05-25 | 2005-11-24 | 2006-05-26 | $3760.00 | Window Closed / Lapsed |
| 11.5 Years (Year 12) | 2009-05-25 | 2009-11-24 | 2010-05-26 | $7700.00 | Window Closed / Lapsed |