WO1999044140A2 - An interactive design tool for shared memory spaces - Google Patents
An interactive design tool for shared memory spaces Download PDFInfo
- Publication number
- WO1999044140A2 WO1999044140A2 PCT/US1999/003397 US9903397W WO9944140A2 WO 1999044140 A2 WO1999044140 A2 WO 1999044140A2 US 9903397 W US9903397 W US 9903397W WO 9944140 A2 WO9944140 A2 WO 9944140A2
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- shared memory
- computing resources
- memory spaces
- information describing
- images
- Prior art date
Links
Classifications
-
- H—ELECTRICITY
- H04—ELECTRIC COMMUNICATION TECHNIQUE
- H04L—TRANSMISSION OF DIGITAL INFORMATION, e.g. TELEGRAPHIC COMMUNICATION
- H04L12/00—Data switching networks
- H04L12/28—Data switching networks characterised by path configuration, e.g. LAN [Local Area Networks] or WAN [Wide Area Networks]
- H04L12/42—Loop networks
- H04L12/427—Loop networks with decentralised control
- H04L12/433—Loop networks with decentralised control with asynchronous transmission, e.g. token ring, register insertion
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F15/00—Digital computers in general; Data processing equipment in general
- G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
- G06F15/163—Interprocessor communication
- G06F15/167—Interprocessor communication using a common memory, e.g. mailbox
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
- G06F9/30003—Arrangements for executing specific machine instructions
- G06F9/3005—Arrangements for executing specific machine instructions to perform operations for flow control
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/451—Execution arrangements for user interfaces
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/465—Distributed object oriented systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5011—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals
- G06F9/5016—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resources being hardware resources other than CPUs, Servers and Terminals the resource being the memory
Definitions
- This invention relates generally to distributed computer systems, and more specifically, to the modeling of object flow in a distributed computer system.
- Distributed computer systems are systems in which the programming and data that the computer operates on are spread out over more than one computer, usually over a network with many computers.
- One conventional method for organizing a distributed system uses the client-server model, in which one part of the distributed system (the client) asks for some service from another part of the distributed system (the server). The server responds and then handles the client's request appropriately.
- the procedure may be implemented using some form of a Remote Procedure Call (RPC): the client informs the server that it would like the procedure executed using certain parameters, the server executes the procedure, and the server returns the results of the execution to the client.
- RPC Remote Procedure Call
- the client-server distributed system model implements a "method-invocation-style" protocol, in which the client and server directly cooperate with one another to execute the desired methods.
- Many distributed algorithms could be better modeled using a flow-of-objects approach, in which the distributed systems protocols are based on the movement of objects into and out of "spaces" (virtual shared memories) designated to hold objects.
- Persistent, shared memory spaces such as in the Linda programming model, are known in the art. See, for example, “Generative Computing in Linda”, David Gelemter, ACM Transactions on Programming Languages and Systems, Vol. 7, No. 1, pp. 80-112 (January 1995); "Persistent Linda: Linda + Transactions + Query Processing", Brian G. Anderson, Dennis Shasha; and "Adding Fault-tolerant Transaction Processing to LINDA", Scott R. Cannon, David Dunn, Software— Practice and Experience, Vol. 24(5), pp. 446-449 (May 1994).
- Fig. 1 is a diagram illustrating an exemplary distributed "book ordering system" 100 using the flow of objects approach to model distributed algorithms.
- objects i.e., data structures that contain behavior and/or data
- Distributed system 100 includes buyer computer 110, broker computer 111, and seller computers 112-114 .
- Spaces 102-105 may be hosted on one of computers 110-115 or on another computer not shown in Fig. 1.
- Buyer 110 submits an object to space 102 that includes a request for bids on the desired book.
- Broker 111 removes the bid request from space 102 and writes the bid request, or an appropriately modified version of the bid request, into spaces 103-105, which correspond to spaces of particular book wholesalers 112-114 that are registered with broker 111.
- a server at each wholesaler 112-114 removes the bid request from its designated space 103-105, respectively, and presents the request to a human.
- the human prepares the bid and then writes the bid back into the wholesalers space for forwarding by broker 111 to space 102 (alternatively, the bid may be written by wholesalers 112-114 straight into public space 102).
- buyer 110 removes the bids from space 102 and presents them to a human to select the winning bid.
- Book ordering system 100 implements a distributed book ordering algorithm using only a single interface, the shared memory space interface, through which computers 110-114 interact.
- a first aspect consistent with the present invention includes a method of generating computer code defining object flow in a shared memory, the method comprising the steps of: (1) displaying a graphical interface in which images representing computing resources and images representing the shared memory spaces are placed; (2) storing information, entered via the graphical interface, that describes object flow between the computing resources and the shared memory spaces; and (3) generating computer code that implements the object flow described between the shared memory spaces and the computing resources.
- a second aspect consistent with the present invention includes a method of generating computer code defining object flow in a shared memory, the method comprising the steps of: (1) placing graphical representations of computing resources on a graphical display area; (2) placing graphical representations of shared memory spaces on the graphical display area; (3) entering information describing data flow between the graphical representations of the computing resources and the graphical representations of the shared memory spaces; and (4) automatically generating computer code that implements the object flow between shared memory spaces corresponding to the graphical representation of the shared memory spaces and between computing resources corresponding to the graphical representations of the computing resources.
- Fig. 1 is a diagram illustrating an exemplary distributed system using the flow of objects approach to model distributed algorithms
- Fig. 2 is a diagram of an exemplary distributed system
- Fig. 3 is a diagram of an exemplary computer within the exemplary distributed system
- Figs. 4A-4D are diagrams illustrating an exemplary graphical interface of the interactive design tool consistent with the present invention.
- Fig. 5 is a flowchart illustrating methods consistent with the present invention for generating computer.
- Fig. 6 is a diagram illustrating an exemplary section of generated computer code. Detailed Description
- An interactive design tool allows a designer to visually define object flow between computing resources and shared memory spaces in a distributed computing system.
- the design tool automatically converts the visual depiction of the object flow to computer code implementing the depicted object flow.
- the exemplary distributed system (1) allows users of the system to share services and resources over a network of many devices; (2) provides programmers with tools and programming patterns that allow development of robust, secured distributed systems; and (3) simplifies the task of administering the distributed system.
- the exemplary distributed system utilizes the JavaTM programming environment to allow both code and data to be moved from device to device in a seamless manner. Accordingly, the exemplary distributed system is layered on top of the Java programming environment and exploits the characteristics of this environment, including the security offered by it and the strong typing provided by it.
- the Java programming environment is more clearly described in Jaworski, Java 1.1 Developer's Guide. Sams.net (1997), which is incorporated herein by reference.
- the exemplary distributed system provides the simphcity of access and the power of sharing that can be provided by a single system without giving up the flexibility and personalized response of a personal computer or workstation.
- the exemplary distributed system may contain thousands of devices operated by users who are geographically disperse, but who agree on basic notions of trust, administration, and policy.
- a "service” refers to a resource, data, or functionality that can be accessed by a user, program, device, or another service and that can be computational, storage related, communication related, or related to providing access to another user.
- Examples of services provided as part of a Djinn include devices, such as printers, displays, and disks; software, such as applications or utilities; information, such as databases and files; and users of the system.
- Both users and devices may join a Djinn.
- the user or device When joining a Djinn, the user or device adds zero or more services to the Djinn and may access, subject to security constraints, any one of the services it contains.
- devices and users federate into a Djinn to share access to its services.
- the services of the Djinn appear programmatically as objects of the Java programming environment, which may include other objects, software components written in different programming languages, or hardware devices.
- a service has an interface defining the operations that can be requested of that service, and the type of the service determines the interfaces that make up that service.
- Fig. 2 depicts the exemplary distributed system 200 containing computer 202, computer 204, and device 206 interconnected by a network 208.
- the device 206 may be any of a number of devices, such as a printer, fax machine, storage device, or other devices.
- the network 208 may be a local area network, wide area network, or the Internet. Although only two computers and one device are depicted as comprising the exemplary distributed system 200, one skilled in the art will appreciate that the exemplary distributed system 200 may include additional computers or devices.
- Fig. 3 depicts computer 202 in greater detail to show a number of the software and hardware components of the distributed system 200.
- Computer 202 includes a memory 302, a secondary storage device 304, a central processing unit (CPU) 306, an input device 308, and a video display or monitor 310.
- the memory 302 includes a lookup service 312, a discovery server 314, and a Java runtime system 316.
- the Java runtime system 316 includes the JavaTM remote method invocation system (RMI) 318 and a Java virtual machine 320.
- the secondary storage device 304 includes a JavaSpace 322.
- the Java runtime system 316 includes the Java API, allowing programs running on top of the Java runtime system to access, in a platform-independent manner, various system functions, including windowing capabilities and networking capabilities of the host operating system. Since the Java API provides a single common API across all operating systems to which the Java runtime system is ported, the programs running on top of a Java runtime system run in a platform-independent manner, regardless of the operating system or hardware configuration of the host platform.
- the Java runtime system 316 is provided as part of the Java software development kit available from Sun Microsystems of Mountain View, CA.
- the Java virtual machine 320 also facilitates platform independence.
- the Java virtual machine 320 acts like an abstract computing machine receiving instructions from programs in the form of byte codes and interpreting these byte codes by dynamically converting them into a form for execution, such as object code, and executing them.
- RMI 318 facilitates remote method invocation by allowing objects executing on one computer or device to invoke methods of an object on another computer or device. Both RMI and the Java virtual machine are also provided as part of the Java software development kit.
- the lookup service 312 defines the services that are available for a particular Djinn. That is, there may be more than one Djinn and, consequently, more than one lookup service within the exemplary distributed system 200.
- the lookup service 312 contains one object for each service within the Djinn, and each object contains various methods that facilitate access to the corresponding service.
- the lookup service 312 and its access are described in greater detail in co-pending U.S. Patent Application No. , entitled "Method and System for Facilitating Access to a Lookup Service," which has previously been incorporated by reference.
- the discovery server 314 detects when a new device is added to the exemplary distributed system 200, during a process known as boot and join or discovery, and when such a new device is detected, the discovery server passes a reference to the lookup service 312 to the new device, so that the new device may register its services with the lookup service and become a member of the Djinn. After registration, the new device becomes a member of the Djinn, and as a result, it may access all the services contained in the lookup service 312.
- boot and join is described in greater detail in co-pending U.S. Patent Application
- exemplary distributed system 200 may contain many lookup services, discovery servers, and JavaSpaces.
- shared memory space refers to any memory that can be viewed or modified by more than one process.
- JavaSpaces such as JavaSpace 322, are used.
- the JavaSpace 322 is an object repository used by programs within distributed system 200 to store objects. Programs use the JavaSpace 322 to store objects persistently as well as to make them accessible to other devices within the Java distributed system. JavaSpaces are described in greater detail in co-pending U.S. Patent Application No. 08/971,529, entitled “Database System Employing Polymorphic Entry and Entry Matching,” assigned to a common assignee, filed on November 17, 1997, which is incorporated herein by reference. A brief review of JavaSpaces follow.
- a JavaSpace holds entries, where an entry is a typed group of objects. An entry can be written into a JavaSpace, which creates a copy of that entry in the JavaSpace. Entries can be looked up in JavaSpaces using templates, which are entry objects that have some or all of its fields set to specified values that must be matched exactly. Remaining fields are left as wildcards- these fields are not used in the lookup.
- JavaSpaces support two kinds of lookup operations: read and take.
- a read request to a JavaSpace returns either an entry that matches the template on which the read is done, or an indication that no match was found.
- a take request operates like a read, but if a match is found, the matching entry is removed from the JavaSpace. Standing requests may be made to the JavaSpace so that the JavaSpace will notify the requestor when an entry that matches a specified template is written.
- All operations that modify a JavaSpace are preferably performed in a transactionally secure manner with respect to that space. That is, if a write operation returns successfully, that entry was written into the space. And if a take operation returns an entry, that entry has been removed from the space, and no future operation will read or take the same entry. In other words, each entry in the JavaSpace can be taken at most once, although two or more entries in a JavaSpace may have exactly the same value.
- An interactive design tool consistent with the present invention allows users to interactively and visually design object data flow through JavaSpaces. Users of the IDT may visually and graphically define the protocol governing the object flow. The IDT may then generate computer code implementing the protocol.
- Figs. 4A-4D are diagrams illustrating an exemplary graphical interface of the IDT consistent with the present invention.
- the EDT is preferably a program executed by computer 202, stored in memory 302, and which presents a graphical interface on display 310.
- graphical interface 400 includes a design area 402 and a tool bar 406.
- design area 402 a programmer places and manipulates graphical representations of JavaSpaces and the clients that access the JavaSpaces.
- Representations of the JavaSpaces and the client computing resources are displayed on tool bar 406.
- JavaSpaces are represented by icon 408 and computing resources by icon 407.
- the programmer may simply click on the JavaSpace icon 308 and drag it into the design area 402.
- Client computers may be similarly added by clicking on icon 407.
- Button 409 labeled "create code,” when activated, causes the IDT to generate the class files that define the entry types in the JavaSpaces and/or generate skeleton code or partial skeleton code of the clients placed in design area 402.
- the IDT Given the information visually depicted in design area 402, the IDT generates computer code representing the functionality defined by the programmer in the design area 402, thus saving the programmer the burden of having to manually write the code.
- the computer code includes implementations of the remote procedure calls performed by the client to the appropriate JavaSpaces.
- tool bar 406 may contain additional icons representing different types of computing resources, or may be implemented as pull-down menus.
- Figs. 4B through 4D are illustrations of interface 400 at various points in the construction of the distributed computing system.
- Fig. 4B is an illustration of design area 402 after the programmer has added JavaSpace 410 to design area 402.
- JavaSpace 410 holds entries that include a "graphics object" that stores portions of an image.
- Fig. 4C is an illustration of design area 402 after the programmer has added a client computer system 412 and indicated that client computer system 412 will write the graphics object entries into JavaSpace 410 (illustrated by line 413).
- the IDT may display dialog box 415, in which the user may enter the name (e.g., "image segment") and the type (e.g., graphics object) of the entry that is to be written into JavaSpace 410.
- additional dialog boxes may be used to enter additional information—such as allowing the programmer to define a new type of object for the JavaSpace.
- Fig. 4D is an illustration of design area 402 after the programmer has added second, third, and fourth client computer systems 416-418, respectively.
- Clients 416 and 417 take entries from JavaSpace 410 and write entries into JavaSpace 410.
- Clients 416 and 417 may be, for example, specialized high speed graphics workstations that perform image processing operations on the graphic object entries in JavaSpace 410. More particularly, clients 416 and 417 monitor space 410 using templates that indicate a match whenever a "graphics object" is written into space 410. The matched objects are then taken by one of clients 416 and 417 from space 410, operated on, and written back into JavaSpace 410.
- Client 418 takes the entries operated on by clients 416 and 417 out of JavaSpace 410.
- the indication of which clients will write, take, or read entries from the JavaSpaces is preferably indicated to the programmer using the lines shown in Figs. 4C and 4D, although other methods of graphically illustrating object-flow may alternatively be used.
- the IDT When client code button 409 is activated by the programmer the IDT generates computer code for each client in design area 402. In the example shown in Fig. 4D, the IDT would generate computer code for clients 412, 416, 417, and 418. In general, for each client, the IDT generates code that performs a write, take, or read operation on the designated JavaSpace(s) using the entry type specified by the programmer.
- Fig. 5 is a flowchart illustrating the generation of computer code by the IDT.
- the IDT generates code for each JavaSpace operation (i.e., for each write, read, or take operation) in each client in the design area.
- the IDT will write a separate program or code module for each client (steps 502, 503).
- the IDT generates code corresponding to each JavaSpace operation (steps 504 and 505).
- the IDT also stores information correlating the code to the visual display area, (step 506), thereby allowing the IDT to appropriately update the code if the programmer changes the visual representation of the distributed system or to update the visual representation if the programmer manually changes the code.
- Fig. 6 is a diagram illustrating an exemplary code module generated for one of clients 416 and 417. As shown in Fig. 4D, each of clients 416 and 417 takes a graphics object and writes a graphics object. These two JavaSpace operations are illustrated as code sections 602 and 604, respectively.
- the programmer may add additional code, such as code sections 601, 603, and 605.
- code section 603 may perform an image processing operation such as an image smoothing operation on the graphics object taken by code section 602.
- Code section 604 writes the smoothed code section back to JavaSpace 410.
- the IDT generates the lines of code corresponding to each JavaSpace operation by looking up the instruction(s) required to implement the JavaSpace operation and adding the appropriate parameter data to the instructions, such as, for example, the name or address of the JavaSpace being operated on and an identification of the entry to be written, taken, or read from the JavaSpace.
- the list of the instructions required to implement the JavaSpace operations is predefined in the IDT.
- the interactive design tool described herein allows a programmer to visually design the high-level flow through a shared memory space in a distributed system and then generate computer code implementing the design.
- the visual representation and the computer code are linked, so that when subsequent changes are made to either one, the other one is automatically updated. This is advantageous, as it allows the programmer to more easily design and layout the object flow in the distributed system. The programmer can then add details and additional functionality to the computer code.
Abstract
Description
Claims
Priority Applications (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
AU27703/99A AU2770399A (en) | 1998-02-26 | 1999-02-17 | An interactive design tool for shared memory spaces |
EP99908213A EP1057114A2 (en) | 1998-02-26 | 1999-02-17 | An interactive design tool for shared memory spaces |
JP2000533823A JP2002505479A (en) | 1998-02-26 | 1999-02-17 | Interactive design tool for shared memory space |
KR1020007008971A KR20010040980A (en) | 1998-02-26 | 1999-02-17 | An interactive design tool for shared memory spaces |
Applications Claiming Priority (4)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US7604898P | 1998-02-26 | 1998-02-26 | |
US60/076,048 | 1998-02-26 | ||
US4493698A | 1998-03-20 | 1998-03-20 | |
US09/044,936 | 1998-03-20 |
Publications (2)
Publication Number | Publication Date |
---|---|
WO1999044140A2 true WO1999044140A2 (en) | 1999-09-02 |
WO1999044140A3 WO1999044140A3 (en) | 1999-11-25 |
Family
ID=26722181
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
PCT/US1999/003397 WO1999044140A2 (en) | 1998-02-26 | 1999-02-17 | An interactive design tool for shared memory spaces |
Country Status (6)
Country | Link |
---|---|
EP (1) | EP1057114A2 (en) |
JP (1) | JP2002505479A (en) |
KR (1) | KR20010040980A (en) |
CN (1) | CN1292113A (en) |
AU (1) | AU2770399A (en) |
WO (1) | WO1999044140A2 (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO2007108934A1 (en) * | 2006-03-16 | 2007-09-27 | Microsoft Corporation | Adaptive power management |
Families Citing this family (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
SE523112C2 (en) * | 2001-07-05 | 2004-03-30 | Anoto Ab | Procedures for communication between a user device that has the ability to read information from a surface, and servers that execute services that support the user device |
US8060603B2 (en) * | 2008-06-18 | 2011-11-15 | Qualcomm Incorporated | Persistent personal messaging in a distributed system |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO1992009948A1 (en) * | 1990-11-30 | 1992-06-11 | Vpl Research, Inc. | Improved method and apparatus for creating virtual worlds |
US5386568A (en) * | 1992-12-01 | 1995-01-31 | Yamaha Corporation | Apparatus and method for linking software modules |
US5455952A (en) * | 1993-11-03 | 1995-10-03 | Cardinal Vision, Inc. | Method of computing based on networks of dependent objects |
-
1999
- 1999-02-17 CN CN99803344A patent/CN1292113A/en active Pending
- 1999-02-17 KR KR1020007008971A patent/KR20010040980A/en not_active Application Discontinuation
- 1999-02-17 EP EP99908213A patent/EP1057114A2/en not_active Withdrawn
- 1999-02-17 WO PCT/US1999/003397 patent/WO1999044140A2/en not_active Application Discontinuation
- 1999-02-17 AU AU27703/99A patent/AU2770399A/en not_active Abandoned
- 1999-02-17 JP JP2000533823A patent/JP2002505479A/en active Pending
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO1992009948A1 (en) * | 1990-11-30 | 1992-06-11 | Vpl Research, Inc. | Improved method and apparatus for creating virtual worlds |
US5386568A (en) * | 1992-12-01 | 1995-01-31 | Yamaha Corporation | Apparatus and method for linking software modules |
US5455952A (en) * | 1993-11-03 | 1995-10-03 | Cardinal Vision, Inc. | Method of computing based on networks of dependent objects |
Non-Patent Citations (1)
Title |
---|
HUNT N: "IDF: A GRAPHICAL DATA FLOW PROGRAMMING LANGUAGE FOR IMAGE PROCESSING AND COMPUTER VISION" PROCEEDINGS OF THE INTERNATIONAL CONFERENCE ON SYSTEMS, MAN, AND CYBERNETICS, LOS ANGELES, NOV. 4 - 7, 1990,4 November 1990 (1990-11-04), pages 351-360, XP000215369 INSTITUTE OF ELECTRICAL AND ELECTRONICS ENGINEERS ISBN: 0-87942-597-0 * |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
WO2007108934A1 (en) * | 2006-03-16 | 2007-09-27 | Microsoft Corporation | Adaptive power management |
US7484110B2 (en) | 2006-03-16 | 2009-01-27 | Microsoft Corporation | Adaptive power management |
Also Published As
Publication number | Publication date |
---|---|
WO1999044140A3 (en) | 1999-11-25 |
JP2002505479A (en) | 2002-02-19 |
AU2770399A (en) | 1999-09-15 |
CN1292113A (en) | 2001-04-18 |
KR20010040980A (en) | 2001-05-15 |
EP1057114A2 (en) | 2000-12-06 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US5949998A (en) | Filtering an object interface definition to determine services needed and provided | |
US6463446B1 (en) | Method and apparatus for transporting behavior in an event-based distributed system | |
US8635540B2 (en) | Method and apparatus for managing internet transactions | |
US6185611B1 (en) | Dynamic lookup service in a distributed system | |
US6532471B1 (en) | Interface repository browser and editor | |
US20020078255A1 (en) | Pluggable instantiable distributed objects | |
US7543238B2 (en) | System and method for directly accessing functionality provided by an application | |
US6263498B1 (en) | Method and apparatus for enabling server side distributed object modification | |
EP1003112A2 (en) | Methods and apparatus for interpreting user selections in the context of a relation distributed as a set of a orthogonalized sub-relations | |
EP0735470A1 (en) | Method and apparatus for determining the type of an object in a distributed object system | |
US20030221165A1 (en) | System and method for metadata-driven user interface | |
US7716347B2 (en) | Method for managing commerce contexts | |
JPH09265408A (en) | Distributed asynchronous work flow on network | |
JPH1091447A (en) | Catalogue device for promoting reusage of distributed object in distribution object system | |
EP1057107A1 (en) | Dynamic lookup service in a distributed system | |
WO2006103264A2 (en) | Managing development of an enterprise application | |
Ali et al. | Ambient-PRISMA: Ambients in mobile aspect-oriented software architecture | |
Wood et al. | A web services architecture for visualization | |
Faraj et al. | Distributed object environment: using international standards for data exchange in the construction industry | |
US20080148169A1 (en) | Tool for configuring available functions of an application | |
EP1057114A2 (en) | An interactive design tool for shared memory spaces | |
Raptis et al. | Multi-technology distributed objects and their integration | |
JP2004110362A (en) | Application development supporting system and application development supporting method and computer program | |
EP1594060A1 (en) | Web application for supporting transaction processing | |
Sauer | Brokering process components |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
WWE | Wipo information: entry into national phase |
Ref document number: 99803344.8 Country of ref document: CN |
|
AK | Designated states |
Kind code of ref document: A2 Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT UA UG UZ VN YU ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A2 Designated state(s): GH GM KE LS MW SD SZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
121 | Ep: the epo has been informed by wipo that ep was designated in this application | ||
DFPE | Request for preliminary examination filed prior to expiration of 19th month from priority date (pct application filed before 20040101) | ||
AK | Designated states |
Kind code of ref document: A3 Designated state(s): AL AM AT AU AZ BA BB BG BR BY CA CH CN CU CZ DE DK EE ES FI GB GD GE GH GM HR HU ID IL IN IS JP KE KG KP KR KZ LC LK LR LS LT LU LV MD MG MK MN MW MX NO NZ PL PT RO RU SD SE SG SI SK SL TJ TM TR TT UA UG UZ VN YU ZW |
|
AL | Designated countries for regional patents |
Kind code of ref document: A3 Designated state(s): GH GM KE LS MW SD SZ UG ZW AM AZ BY KG KZ MD RU TJ TM AT BE CH CY DE DK ES FI FR GB GR IE IT LU MC NL PT SE BF BJ CF CG CI CM GA GN GW ML MR NE SN TD TG |
|
WWE | Wipo information: entry into national phase |
Ref document number: 1020007008971 Country of ref document: KR |
|
ENP | Entry into the national phase in: |
Ref document number: 2000 533823 Country of ref document: JP Kind code of ref document: A |
|
WWE | Wipo information: entry into national phase |
Ref document number: 1999908213 Country of ref document: EP |
|
WWP | Wipo information: published in national office |
Ref document number: 1999908213 Country of ref document: EP |
|
REG | Reference to national code |
Ref country code: DE Ref legal event code: 8642 |
|
WWP | Wipo information: published in national office |
Ref document number: 1020007008971 Country of ref document: KR |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 1999908213 Country of ref document: EP |
|
WWW | Wipo information: withdrawn in national office |
Ref document number: 1020007008971 Country of ref document: KR |