GB2328764A - Passing programming constructs across a foreign interface - Google Patents
Passing programming constructs across a foreign interface Download PDFInfo
- Publication number
- GB2328764A GB2328764A GB9718137A GB9718137A GB2328764A GB 2328764 A GB2328764 A GB 2328764A GB 9718137 A GB9718137 A GB 9718137A GB 9718137 A GB9718137 A GB 9718137A GB 2328764 A GB2328764 A GB 2328764A
- Authority
- GB
- United Kingdom
- Prior art keywords
- information
- language
- token
- interface
- application
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
Classifications
-
- 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/54—Interprogram communication
- G06F9/542—Event management; Broadcasting; Multicasting; Notifications
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Multimedia (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Memory System Of A Hierarchy Structure (AREA)
- Multi Processors (AREA)
Abstract
Passing information, such as an object or other programming construct, between two computer software applications 11, 13, which would usually communicate through a language independent interface 12. Sending application 11 sends an item of information to be transferred to a memory store such as a cache 14, without first converting the information to the neutral interface language. A token uniquely representing that item of information is returned to the sending application 11, and then passed through interface 12, where it is converted to the neutral language, and received by receiving application 13 which converts the token back to its native language. Receiving application 13 uses the token to access the information stored in store 14. Processing load is reduced since, despite the presence of the language independent interface 12, the information to be transferred need not be converted to language neutral form.
Description
METHOD APPARATUS AND COMPUTER PROGRAM PRODUCT
FOR PASSING PROGRANNING CONSTRUCTS ACROSS A FOREIGN INTERFACE
Field of the Invention
The present invention relates to the field of computing, and more specifically to the field of distributed computing where two independent pieces of software (hereinafter referred to as "applicationsll) are working together in such a way that they need to share information amongst themselves.
Background of the Invention
In modern computing systems, it is becoming more and more common for two different applications to share information whilst performing their respective computer processing tasks. In order to make it easier for an application written in one programming language to understand the information that comes from an application written in another programming language, language independent interfaces have been developed, through which all information must pass on its way from one application to another. A first application that is sending information must first translate the information into a neutral language of the interface and then send the translated information to the interface which will then pass the information on to the receiving application which then converts the information from the neutral language to the native language of the receiving application.
An example of such an interface and neutral language is the
Interface Definition Language (IDL) defined by the Object Management
Group (OMG) as part of its Common Object Request Broker Architecture (CORBA). The OMG is a consortium of computer software companies which have agreed to develop distributed applications that conform to defined standards. The technology is based on object-oriented programming, where data and the programming methods that act on the data are grouped together as an atomic unit called an object for treatment by the overall computer program. Thus, in this example, each of the two applications would be objects and the information being passed between them is also likely to be an object.
Another example is an operating system interface through which information is passed from one application to another, along with a conversion to/from a neutral language of the interface.
Because it is very common that the two applications will be written in different programming languages, many systems are designed so that all information that passes between applications must first be converted to the neutral language and passed through the interface.
Oftentimes, the two applications will be in the same language and thus there is no real need to convert the information to the neutral language before passing the information through the interface from one application to the other. However, because of the above constraint of always passing everything through the interface, this conversion to the neutral language is necessary even when the two applications are in the same language. Thus, in these cases, the two applications wishing to share information must convert all of the information to/from the neutral language, presenting a burden on the applications which is unnecessary, since the two applications are in the same language to start with.
Summarv of the Invention
According to a first aspect, the present invention provides a method of passing information between two computer software applications, the two applications normally communicating with each other by first converting information to a neutral interface language and then passing the information through a language independent interface, the method having steps of: the sending application sending an item of information to a memory store without first converting the information to the neutral interface language; returning a token representing the item of information to the sending application; the sending application sending the token through the interface to a receiving application; and the receiving application using the token to access the information stored in the memory store.
Preferably, the memory store is a cache and the item of information is a software construct. Further preferably, the software construct is an object.
Further preferably, each time another item of information is stored in the memory store a value of a token to be assigned to this item of information is incremented by one with reference to the value of the token which was assigned to the immediately preceding item of information stored in the memory store.
According to a second aspect, the present invention provides an apparatus for carrying out the method steps described above in the first aspect.
According to a third aspect, the present invention provides a computer program product stored on a computer readable storage medium for, when run on a computer, carrying out the method steps of the first aspect.
Thus, with the present invention, all of the information passing between two applications of the same native langauge need not be first converted to the neutral language of the interface, even though there has been a previous commitment to converting all inter-application information to the neutral language when the system architecture was established. Some of the information, instead, is sent around the interface using a memory store and tokens as will be described below.
This greatly reduces the processing load on the two applications, as much language conversion can be saved.
Brief DescriDtion of the Drawings
The present invention will be better understood by a reading of the below described preferred embodiments thereof in conjunction with the following drawing figures:
Figure 1 is a block diagram showing the basic system architecture according to a preferred embodiment of the present invention; and
Figure 2 is a flowchart showing the steps involved in transferring information from one application to another, according to a preferred embodiment of the present invention.
Detailed DescriDtion of the Preferred Embodiments
As shown in Fig. 1, according to the basic system architecture of a preferred embodiment of the present invention, a first application 11 transfers information through a language neutral interface 12 to a second application 13. The first and second applications share the same native programming language (e.g., C++ or Java). The information passing between the two applications can be, for example, an object, or some other form of programming construct.
In the prior art, all information passing between the two applications 11 and 13 had to be passed through the interface 12 along with the attendant conversion to the neutral language. However, according to a preferred embodiment of the present invention, a cache 14 (or some other type of memory store) is provided so that information may be sent around the interface 12 from application 11 to application 13 without first being converted to the neutral language.
Now, the operation of the present invention will be described with reference to the block diagram of Fig. 1 and the flowchart of Fig. 2.
Note that in Fig. 1, the encircled numbers defines the time order in which the steps take place.
First, application 11 sends (step 21, Fig. 2) a programming construct (hereinafter, an object will be used as the programming construct or information that is being passed between applications as an example) to the cache 14 (see encircled number 1). A unique token (e.g., an unsigned number) is then returned (step 22) to application 11 (see encircled number 2), the token uniquely representing the object just stored in the cache 14. For example, the value of the token could be incremented by one each time a new item of information is added to the cache 14, so as to uniquely identify each stored item of information with a token.
Application 11 then passes (step 23) the token through the interface 12, after converting the token to the neutral language (encircled number 3). Upon receiving the token, application 13 converts the token from the neutral language back to the native language and then sends (step 24) the token to the cache 14 (see encircled number 4). The object previously stored there by application 11 is then identified by the token (which is unique to this stored object) and retrieved from the cache 14 and sent (step 25) to application 13 (see encircled number 5).
It should be noted that the cache 14 can be implemented either in software (i.e., as a map or an array) or in hardware.
In this way, there is no need to convert the object to the language neutral form, yet it still can be transferred between application 11 and application 13 despite the presence of the interface 12 between application 11 and application 13. Instead, only a token need be so converted and passed through the interface 12. This greatly reduces the processing load associated with applications 11 and 13 as the need for language conversion with respect to objects sent to the cache 14 is eliminated. Thus, the applications become much more easier to write.
Further, since objects are removed from the cache when the receiving application retrieves them therefrom, the contents of the cache can be kept very small, thus reducing the memory size requirements.
Claims (10)
1. A method of passing information between two computer software applications, said two applications normally communicating with each other by first converting information to a neutral interface language and then passing the information through a language independent interface, said method comprising the steps of:
the sending application sending an item of information to a memory store without first converting the information to said neutral interface language;
returning a token representing the item of information to the sending application;
the sending application sending the token through the interface to a receiving application; and
the receiving application using the token to access the information stored in the memory store.
2. The method of claim 1 wherein said memory store is a cache memory.
3. The method of claim 1 wherein said item of information is a software construct.
4. The method of claim 3 wherein said software construct is an object.
5. The method of claim 1 wherein each time another item of information is stored in said memory store a value of a token to be assigned to this item of information is incremented by one with reference to the value of the token which was assigned to the immediately preceding item of information stored in said memory store.
6. An apparatus for passing information between two computer software applications, said two applications normally communicating with each other by first converting information to a neutral language and then passing the information through a language independent interface, said apparatus comprising:
means for sending an item of information from a sending application to a memory store without first converting the information to said neutral interface language;
means for returning a token representing the item of information to the sending application;
means for sending the token from the sending application through the interface to a receiving application; and
means for having the receiving application use the token to access the information stored in the memory store.
7. The apparatus of claim 6 wherein said memory store is a cache memory.
8. The apparatus of claim 6 wherein said item of information is a software construct.
9. The apparatus of claim 8 wherein said software construct is an object.
10. A computer program product stored on a computer readable storage medium for, when run on a computer, implementing a method of passing information between two computer software applications, said two applications normally communicating with each other by first converting information to a neutral interface language and then passing the information through a language independent interface, said method comprising the steps of:
the sending application sending an item of information to a memory store without first converting the information to said neutral interface language;
returning a token representing the item of information to the sending application;
the sending application sending the token through the interface to a receiving application; and
the receiving application using the token to access the information stored in the memory store.
Priority Applications (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
GB9718137A GB2328764B (en) | 1997-08-28 | 1997-08-28 | Method, apparatus and computer program product for passing programming constructs across a foreign interface |
JP18643798A JPH1185548A (en) | 1997-08-28 | 1998-07-01 | Information sending method, device therefor and computer program products |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
GB9718137A GB2328764B (en) | 1997-08-28 | 1997-08-28 | Method, apparatus and computer program product for passing programming constructs across a foreign interface |
Publications (3)
Publication Number | Publication Date |
---|---|
GB9718137D0 GB9718137D0 (en) | 1997-10-29 |
GB2328764A true GB2328764A (en) | 1999-03-03 |
GB2328764B GB2328764B (en) | 2002-01-23 |
Family
ID=10818094
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
GB9718137A Expired - Fee Related GB2328764B (en) | 1997-08-28 | 1997-08-28 | Method, apparatus and computer program product for passing programming constructs across a foreign interface |
Country Status (2)
Country | Link |
---|---|
JP (1) | JPH1185548A (en) |
GB (1) | GB2328764B (en) |
Cited By (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8171487B2 (en) * | 2007-05-02 | 2012-05-01 | International Business Machines Corporation | Method for processing work items of a workflow system |
Families Citing this family (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7200576B2 (en) * | 2005-06-20 | 2007-04-03 | Microsoft Corporation | Secure online transactions using a captcha image as a watermark |
US9213992B2 (en) | 2005-07-08 | 2015-12-15 | Microsoft Technology Licensing, Llc | Secure online transactions using a trusted digital identity |
US8145914B2 (en) | 2005-12-15 | 2012-03-27 | Microsoft Corporation | Client-side CAPTCHA ceremony for user verification |
Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP0518195A2 (en) * | 1991-06-12 | 1992-12-16 | International Business Machines Corporation | Method and system for exchanging information between application programs |
US5313578A (en) * | 1990-12-23 | 1994-05-17 | Motorola, Inc. | Portable interprocess communication facility |
-
1997
- 1997-08-28 GB GB9718137A patent/GB2328764B/en not_active Expired - Fee Related
-
1998
- 1998-07-01 JP JP18643798A patent/JPH1185548A/en active Pending
Patent Citations (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US5313578A (en) * | 1990-12-23 | 1994-05-17 | Motorola, Inc. | Portable interprocess communication facility |
EP0518195A2 (en) * | 1991-06-12 | 1992-12-16 | International Business Machines Corporation | Method and system for exchanging information between application programs |
Cited By (2)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8171487B2 (en) * | 2007-05-02 | 2012-05-01 | International Business Machines Corporation | Method for processing work items of a workflow system |
US8819696B2 (en) | 2007-05-02 | 2014-08-26 | International Business Machines Corporation | Method and system for processing work items |
Also Published As
Publication number | Publication date |
---|---|
GB2328764B (en) | 2002-01-23 |
GB9718137D0 (en) | 1997-10-29 |
JPH1185548A (en) | 1999-03-30 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6718550B1 (en) | Method and apparatus for improving the performance of object invocation | |
EP0648354B1 (en) | Method and system for implementation-independent interface specification | |
US6272557B1 (en) | Framework for marshaling and unmarshaling argument object references | |
US5860072A (en) | Method and apparatus for transporting interface definition language-defined data structures between heterogeneous systems | |
US6405264B1 (en) | Marshaling and unmarshaling framework for supporting filters in a distributed object system | |
EP0733970B1 (en) | Methods and apparatus for managing collections of objects | |
US20090228899A1 (en) | Method and apparatus for dynamically brokering object messages among object models | |
US20020038390A1 (en) | Method and apparatus for fast, local corba object references | |
US6249803B1 (en) | Method and apparatus for executing code during method invocation | |
WO1998002809A1 (en) | Method and apparatus for asynchronously calling and implementing objects | |
JPH0922392A (en) | Method and device for conspiracy between objects | |
CA2255393A1 (en) | Method and apparatus for constructing stable iterators in a shared data collection | |
US20020147962A1 (en) | Method and system for incorporating legacy applications into a distributed data processing environment | |
US6516354B2 (en) | Method and apparatus for efficient representation of variable length identifiers in a distributed object system | |
JPH11312151A (en) | High-speed distribution object request broker | |
JP2008165340A (en) | Remote procedure calling system | |
US8549269B2 (en) | Method, apparatus or software for processing exceptions produced by an application program | |
CN113849449A (en) | Communication system and information interaction method, device and medium | |
GB2328764A (en) | Passing programming constructs across a foreign interface | |
US20080082473A1 (en) | Peer based event conversion | |
US5838971A (en) | Process for implementing dynamic data types in distributed computing networks using an OSF/DCE platform | |
JP4835313B2 (en) | Software module linkage system | |
US20020178141A1 (en) | Method and apparatus for remote inter-language method calling | |
KR100272094B1 (en) | Object migration system and method | |
EP0817021A1 (en) | Multimedia server |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
PCNP | Patent ceased through non-payment of renewal fee |
Effective date: 20020423 |