Interprocess application programming interface for computer applications

Abstract

One or more embodiments of the invention provide a method, apparatus, and article of manufacture for collaborating application programs executing on a client such as a personal digital assistant (PDA). A shared database on the client is obtained and used as a common launch parameter stack. One or more program entry records are stored in the database and the last program entry record stored is identified as the top of the stack. Each program entry record may include information regarding an application launched on the client. When the last program identified on the stack has completed execution, the last program entry record is popped off of the stack. Thereafter, control is returned to an application that corresponds to the new program entry record on the top of the stack.

Description

BACKGROUND OF THE INVENTION

[0015] 1 . Field of the Invention

[0016] The present invention relates generally to computers and personal digital assistants (PDAs), and in particular, to a method, apparatus, and article of manufacture for collaborating between application programs executing on a computer or PDA.

[0017] 2. Description of the Related Art

[0018] Prior art handheld computing devices (also referred to as palm PCs or personal digital assistants (PDAs)), are often used to access and utilize personal information. Many handheld computing devices are available in today's marketplace. Typically, handheld computing devices are only slightly larger than the size of one's palm (hence, the name palm PC) and have a small display screen for viewing a plethora of items. Software can be installed on a PDA to provide enhanced functionality. For example, a personal productivity tool may be installed to provide access to a calendar, contacts, email, Internet browsing, audio books, and audio recording capabilities. Card slots may also be available to provide additional memory or other functions (e.g., a modem). Additionally, some PDAs have infrared (IR) potts for communication.

[0019] Applications executing on a PDA may utilize and work with itself (by calling or launching a second instance of itself) or other applications on the PDA. For example, an information contact application that provides contact information for businesses and individuals may collaborate and work with a delivery application that transmits email or a fax to a listed contact using a wireless modem. In another application, a geographic information system (GIS) that provides for the retrieval and display of geographic information (e.g., maps) may call itself or collaborate with an Internet application (e.g., an application utilized to browse the Internet such as AvantGo™) to retrieve updated geographic information.

[0020] In the prior art, application collaboration on a PDA was not possible. For example, Waba (a programming platform that may include a language, virtual machine, class file format, and set of base classes) has no way to call outside itself, nor a way to remember the context it was in when returning from calling an application. Further, on a PDA, two instances of the same application may not be executed in parallel. Additionally, the use of a database to collaborate applications on a desktop workstation or computer was not performed.

SUMMARY OF THE INVENTION

[0021] One or more embodiments of the invention provide an application launch parameter stack for collaborating applications on a personal digital assistant (PDA) or computer. When a first application (referred to as a caller application) desires to call a second application (referred to as the called application), the caller application pushes two program entry records onto a stack stored in a database of the PDA or computer. The first program entry record provides state/context information for when the caller application returns. The second program entry record provides launch information for the called application.

[0022] When the called application is launched, it checks the stack, reads the necessary parameters, if any, and executes. Upon completing execution, the called application pops its own program entry record off of the stack, adjusts the stack pointer, appends any return values to the caller application's program entry record, launches the caller application, and terminates itself. The caller application reads the program entry record, restores its state, uses any return values, if necessary, pops its program entry record, and continues execution.

[0023] Accordingly, the stack allows an application running on the PDA or computer to call another application and pass context parameters. Further, the stack allows a called application to complete execution and return control to the original caller application. Thus, the state of the calling application is preserved and may be restored. Additionally, error conditions that may result from the improper termination of an application may be handled by examining and utilizing the stack.

BRIEF DESCRIPTION OF THE DRAWINGS

[0024] Referring now to the drawings in which like reference numbers represent corresponding parts throughout:

[0025] FIG. 1 schematically illustrates a hardware and software environment for the architecture in accordance with one or more embodiments of the invention;

[0026] FIG. 2 is a flow chart illustrating the actions upon the launch of an application/program in accordance with one or more embodiments of the invention;

[0027] FIG. 3 is a flow chart illustrating the use of a stack and how a caller program calls a called program in accordance with one or more embodiments of the invention; and

[0028] FIG. 4 is a flow chart illustrating the actions taken when a called application has completed executing in accordance with one or more embodiments of the invention.

DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0029] In the following description, reference is made to the accompanying drawings which form a part hereof, and which is shown, by way of illustration, several embodiments of the present invention. It is understood that other embodiments may be utilized and structural changes may be made without departing from the scope of the present invention.

[0030] General Architecture

[0031] Hardware Environment

[0032] Collaboration between applications executing on a PDA or computer is provided. FIG. 1 schematically illustrates a hardware and software environment for the architecture in accordance with one or more embodiments of the invention. A typical distributed computer system 100 uses a network/Internet 118 to connect technicians utilizing PDA clients 102 (e.g. a WINCE or PALM device) or desktop clients (e.g., a computer system running a browser) to server computers 106.

[0033] A PDA client includes three classes of devices: handheld personal computers (HPC), palm-held personal computers (PPC or PDA), and smart phones. However, embodiments of the invention may be implemented on desktop clients as well. Hereafter, PDA clients 102 and desktop clients may be used interchangeably and refer to all types of clients/client computer systems. A typical combination of resources used in system 100 may include a network/Internet 118 comprising the Internet, LANs, WANs, SNA networks, or the like, PDA clients 102, desktop clients, and servers 106 that are personal computers, workstations, minicomputers, or mainframes.

[0034] The network/Internet 118 connects PDA clients 102 or desktop clients executing the appropriate software applications 130 to server computers 106. Server computers 106 may execute a variety of applications including a Web server 110, MapGuide server 120, or servlet 108. MagGuide servers 120 and servlets 108 may be located within or part of Web server 110. The server 106 and its components may also be referred to as a back office system. Such a back office system mtaints access to corporate databases, synchronization utilities, etc. The Web server 110 is typically a program such as a UNIX Apache Web server or Microsoft's Internet Information Server. The servlet 108 may communicate with a client 102 through Web server 110 such that any additional processing required by a client 102 may be performed by the servlet 108. In a GIS system, servlet 108 may communicate with MapGuide server 120 to obtain needed map data/information. Additionally, servlet 108 may access map windows files (MWF 124) to obtain relevant data. The servers 106 may also execute a Common Gateway Interface (CGI) 112 (or Netscape Application Programming Interface (NSAPI), Internet Server Application Programming Interface (ISAPI), etc.), which interfaces between the Web server 110 and a database management system (DBMS) 114 that may be utilized to retrieve relevant geographical data (such as SDF data, raster data, Open DataBase Connectivity (ODBC) data, etc.) from database 116.

[0035] Generally, components 108-116 and 120-130 all comprise logic and/or data that is embodied in or retrievable from a device, medium, signal, or carrier, e.g., a data storage device, a data communications device, a remote computer or device coupled to the computer via a network or via another data communications device, etc. Moreover, this logic and/or data, when read, executed, and/or interpreted, results in the steps necessary to implement and/or use the present invention being performed.

[0036] Thus, embodiments of the invention may be implemented as a method, apparatus, or article of manufacture using standard programming and/or engineering techniques to produce software, firmware, hardware, or any combination thereof. The term “article of manufacture” (or alternatively, “computer program product”) as used herein is intended to encompass logic and/or data accessible from any computer-readable device, carrier, or media.

[0037] Those skilled in the art will recognize many modifications may be made to this exemplary environment without departing from the scope of the present invention. For example, those skilled in the art will recognize that any combination of the above components, or any number of different components, including different logic, data, different peripherals, and different devices, may be used to implement the present invention, so long as similar functions are performed thereby.

[0038] Software Embodiments

[0039] The user of a client 102 such as a PDA may execute one or mote applications 130. The architecture of the invention accommodates various PDA clients 102 such as Palm OS devices, WINDOWS CE 2.x devices, and/or smart phones with bitmapped graphics (e.g., SYMBIAN, MOTOROLA, NOKIA, PSION). Further, the architecture of the invention may accommodate desktop or other clients.

[0040] To enable collaboration between applications 130 executing on a client 102, an inter-application application programming interface (API) may be provided. The API provides various functions that may be utilized to control the execution of applications on the client 102. Application 130 collaboration is achieved using a client 102 local database and application launching codes. The client 102 database is utilized as a common state stack for applications 130 collaborating. There may be exceptions for applications that do not share the common state stack. Further, one objective may be to minimize the number of interprocess application programming interfaces utilized by varying applications.

[0041] A variety of mechanisms may be used to represent the database as a stack. For example, in the Palm Operating System, a catalog database is used. In a WinCE device, such a catalog may be emulated on a WinCE database. To allow applications on the client 102 to be called with parameters from Waba or other applications, a call stack in a client 102 database (e.g., a Palm catalog database) file is implemented. All cooperating applications read from and write to this single stack database.

[0042] The stack allows an application to call another application (and pass context parameters), preserves and restores the state of the original (calling application), handles error conditions that may result from the improper termination of an application, and allows the other application to complete execution and return control to the original application.

[0043] The stack records information about the order of application calls, initialization parameters to be used by the called application, and the state (or context) for the calling application.

[0044] Stack Structure

[0045] The stack structure may include a first record that contains a number and one or more additional records that contain program entries. The first record in the database contains a stack pointer which may comprise the number of entries in the stack (written as a byte, for example). This value can be used to help validate the stack. For example, the value of the first record may always be one less than the count of records in the stack, so it can be used to validate the number of entries in the stack.

[0046] Each record after the first record represents a program entry. The program entries may alternate between launch parameters used for returning to the calling program and launch parameters for the called program.

[0047] The last record containing a valid value is referred to as the top-of-the-stack. A program entry may contain information about a program launched on the client 102. For example, Table 1 illustrates the information that may be contained in a program entry record.

TABLE 1
		OP-		OP-
PRO-	<TAB>	TIONAL	<TAB>	TIONAL	<TAB>	LAUNCH
GRAM		PARA-		LAUNCH		PARA-
NAME		METERS		NUMBER		METERS

[0048] As indicated in Table 1, the program entry record may contain the name of the launched program, followed by a TAB delimiter (to support application names containing spaces), optional parameters to the program for Win CE or nothing on Palm OS, another TAB delimiter, an optional launch number for Palm OS or nothing on WinCE, another TAB delimiter, and finally followed by its launch parameters in a string UTF (universal transformation format) format (the string UTF format allows language independence). The launch parameters may also be in the CGI (common gateway interface) format (e.g., conimand?parameter=value&parameter=value). The strings may not be URL encoded. Further, there may be no limit to the depth of the stack. Alternatively, the stack may have a depth limitation implied that is based on the number of bytes or size of the stack count record.

[0049] Table 2 summarizes the format of a program entry record for each platform.

	TABLE 2
	Field	WinCE	PalmOS
	Program name	YES	YES
	TAB	YES	YES
	Parameters to	Optional	NO
	above program.
	For example,
	launching Waba
	with special stack,
	etc.
	TAB	YES	YES
	Launch Number	NO	Optional
	TAB	YES	YES
	Launch parameters	Optional	Optional

[0050] For example, an instance of the stack (with 2 program entries) is illustrated in Table 3.

TABLE 3
2
OnSite<TAB><TAB><TAB>goToMapSet?Mapset=AAAA&Map=3&
displayCenterX=100&displayCenterY=100
AvantGo<TAB><TAB><TAB>AdsetUrl?URL=http://foo.com&
OtherParam=5&AnotherParam=Y

[0051] In Table 3, the first record contains the number 2 for the two program entry records in the stack. The first program entry contains the program name “OnSite” followed by a <TAB> delimiter, no optional parameters, a second <TAB> delimiter, no optional launch number, a third <TAB> delimiter, and launch parameters in a CGI format. The launch parameters provide a command “goToMapSet” followed by parameters and their values—Mapset with a value of AAAA, Map with a value of 3, displayCenterX with a value of 100, and displayCenterY with a value of 100.

[0052] Similarly, the second program entry record contains the program name “AvantGo” followed by a <TAB> delimiter, no optional parameters, a second <TAB> delimiter, no optional launch number, a third <TAB> delimiter, and launch parameters in a CGI format. The launch parameters provide a command ADsetUrl followed by various parameters and values—a URL parameter with a value of http://foo.com, an OtherParam parameter with a value of 5, and an AnotherParam parameter with a value of Y.

[0053] Stack Operation

[0054] The stack is most often utilized when an application (referred to as a “caller” application) desires to call or execute another application (referred to as a “called” application). When the caller intends to launch the called application with a parameter list, the caller application pushes two program entries onto the stack. First, the caller application pushes the program entry that the called application will use to return to the caller. Then, the caller application pushes the program entry that will be used by the called application. As a side effect of the two pushes, an application is able to tell whether it is being called or returned. For example, if the number of entries in the stack is even, then the application is being called. If the number of entries in the stack is odd, then the program is returning from a call.

[0055] If an error code or other return values are returned by the called application, then these values may be appended into the calling program's return parameter record as name/value pairs. For example: &param1=value&param2=value&Return=OK.

[0056] Thus, the following describes an overview of the stack operation. While the caller application is running, the stack may be empty. When the caller application desires to execute the called application, the caller application pushes its own state information onto the stack and then pushes information onto the stack for the called application. The called application uses the information on the stack to execute. Upon completing its execution, the called application may append return values onto the caller application's program entry record and then pops its own information off of the stack and returns control to the caller application. The caller application may utilize any return values provided by the called application and then pops its information off of the stack to continue its execution.

[0057] FIG. 2 is a flow chart illustrating the actions upon the launch of an application/program in accordance with one or more embodiments of the invention. At step 200, the application is called. At step 202, the application determines if a stack exists. If a stack does not exist, execution continues at step 204. However, if a stack does exist, the application determines if it is at the top of the stack at step 206. If the called/launched application is not at the top of the stack, then the stack is invalid, has been corrupted, or an error has occurred. Accordingly, the stack is reset at step 208 and the application continues execution at step 204. Such continued execution may result pursuant to a default mode that permits such execution. The stack may be reset by completely deleting the stack or by removing all of the program entry records in the stack.

[0058] If the top of the call-stack contains the program name of the currently running program, the program should attempt to run given the parameters on this program entry. In attempting to run, the application determines if it is being returned to by an application it has called (i.e., whether it is the caller application), or if it is being called by another application or being launched (i.e., whether it is the called application) at step 210. As described above, to determine whether it is being called or returned to, the application may merely determine whether there are an even number of entries or odd number of entries on the stack. Since two entries are pushed onto the stack every time an application is called, if the application is being called, there are an even number of entries. Similarly, when an application has completed execution and is returning control to the caller application, the called application pops its entry off the stack, leaving an odd number of stack records. Thus, if the application is being returned, there are an odd number of entries on the stack.

[0059] If the application is being returned, the application restores its state by examining its program entry record at step 212. At step 214, the application reads any return values appended in the program entry record. The application then continues execution at step 220. If the application is being launched/called, it reads the parameters from the program entry record at step 218, and continues execution at step 220.

[0060] Thus, upon program startup, the application reads the application launch parameter stack to determine how to proceed.

[0061] FIG. 3 is a flow chart illustrating the use of a stack and how a caller program calls a called program in accordance with one or more embodiments of the invention. At step 300, the caller application pushes a program entry record for the caller application return onto the stack. Thus, the state information for the caller application that allows the caller application to restore its state upon returning is pushed onto the stack. At step 302, the caller application pushes a program entry record for the called application launch information onto the stack. The pushed information can then be used (as indicated in step 218 of FIG. 2) for the launched application to properly execute. At step 304, the stack pointer is adjusted to point to the top of the stack. Thus, if the stack pointer is a pointer, it points to the called application program entry. Similarly, if the stack pointer is a number that reflects the number of entries in the stack, the number may be increased by two (2) to accommodate the two recent program entry record additions performed at steps 300 and 302.

[0062] At step 306, top of the stack program entry (i.e., the called application) is launched/called by the caller application. At step 308, the caller application may terminate itself On the Palm OS, the caller application termination may automatically result when the called application is launched. On the Windows CE, the caller application may have to terminate itself FIG. 4 is a flow chart illustrating the actions taken when a called application has completed executing in accordance with one or mote embodiments of the invention. To complete execution, a “Done” button or completion operation may be selected by a user. Alternatively, application execution may terminate without user interaction. Under either scenario, a script may execute for proper stack operation. At step 400, the called application has completed executing. At step 402, the called application pops its application program entry off of the stack. At step 404, the called application adjusts the stack pointer as necessary (e.g., to point to the prior record in the stack). At step 406, a determination is made regarding whether the stack is now empty. If the stack is empty (i.e., there are no other applications to execute), the operations are complete and no further action may be necessary at step 408.

[0063] If the stack is not empty, the called application appends any return values to the caller application's program entry record at step 410. At step 412, the called application launches the caller application. The called application then terminates execution at step 414. Thereafter, operations proceed as described in FIG. 2.

[0064] Accordingly, FIGS. 2-4 describe the stack operation in accordance with one or more embodiments of the invention.

[0065] To more fully understand the stack operation, it is useful to describe some examples. The examples below show only a single level of calling; however, cooperating applications may be chained together arbitrarily.

[0066] The following example describes the operations for calling the AvantGo application (a Mobile Application Linking (MAL)-compliant application). When AvantGo is called, if the stack database does not exist, the program should come up as it normally does. If the stack database exists, it should ensure that the top of the stack contains AvantGo for the program entry. If the top of the stack contains AvantGo for the program entry, then it should display the URL described in the program entry parameters. However, if the top of the stack does NOT contain AvantGo (error condition), AvantGo may reset the stack by deleting the catalog database, and come up as it normally does (the “done” action will exit the AvantGo). For example, AvantGo may go to a URL (http://foo.com) given the following stack:

2
OnSite<TAB><TAB><TAB>goToMapSet?Mapset=AAAA&Map=3&
displayCenterX=100&displayCenterY=100
AvantGo<TAB><TAB><TAB>AdsetUrl?URL=http://foo.com&Oth
erParam=5&AnotherParam=Y

[0067] The number 2 refers to the record number starting from 0 of the current stack element. The number 2 is then followed by two records each containing “program parameters”.

[0068] Upon AvantGo completing execution (e.g., when a “Done” action is executed), the last record in the stack database (i.e., the program entry for AvantGo) is popped. The count entry in record 0 is then decremented by one (in step 404 of FIG. 4). If a return value or values are needed (a return may be optional), AvantGo appends them to the record at the top of stack in the form:

[0069] “&Return=OK&param1=value&param2=value” (at step 410 of FIG. 4). The current last program entry (in this case OnSite) is then executed (at step 412 of FIG. 4) and execution of AvantGo is terminated (at step 414 of FIG. 4) (on the Palm OS, this may happen automatically when the last program entry is executed. Once the above actions have been completed, the stack would look as follows:

1
OnSite<TAB><TAB><TAB>goToMapSet?Mapset=AAA
A&Map=3&displayCenterX=100&displayCenterY=100&Re
turn=Failure

[0070] Any exit from a cooperating application that does not use a special “Done” button may terminate the application without attempting to return to the calling application. In such a situation, there may not be any special processing of the stack required and embodiments may not attempt to prevent such exits.

[0071] In accordance with one or more embodiments of the invention, an in-process API may be provided for 3rd party applications running inside Waba, C, or the Java environment, that extends the functionality of a GIS executing on a PDA. In this scenario, the GIS may function as a library or DLL (dynamic link library) that is linked to the extending application. This type of API may be development platform-dependant.

[0072] The AvantGo application may be configured to work with the stack as described above. When configured, the AvantGo application may implement a “setURL” function that causes an URL (specified in the stack) to be displayed immediately upon launch. Further, a special “Done” script may cause AvantGo to return control to the application that called it, when a button on an HTML page that calls the script is pressed.

[0073] In the following example, an application called “AAA” wishes to execute function “foo” in application “BBB”. Initially, application “AAA” prepares to call application “BBB”. As part of this preparation, application “AAA” pushes information for its own return (record 1 below), then it pushes the launch information to be used by application “BBB” (record 2 below.) Application “AAA” then sets the stack pointer (record 0 below) to “2”. Just before application “BBB” is actually launched, the stack appears as follows:

Record Contents
0      2
1      AAA<tab>param<tab>launchNumber<tab>returnLocation?ret
       urnParam1=395&anotherReturnParam=Yes
2      BBB<tab><tab><tab>foo?someParam=3&anotherParam=
       “A Quoted Text String”&lastParam=−12.3

[0074] With the stack in this state, application “AAA” launches application “BBB” and terminates itself Upon startup, application “BBB” will check the top of the stack and determine that it is being launched to execute function “foo” with the given parameter list.

[0075] Once application “BBB” has completed executing, it prepares to return to application “AAA”. Thus, when application “BBB” has completed function “foo”, it pops its own parameter list off the stack. If, as in this example, a return value requires a return value, then application “BBB” must append a name/value pair string to application “AAA”'s return parameter list. In this example, the return parameter is “Return” and its value is “OK”. The stack will appear as follows:

Record Contents
0      1
1      AAA <tab>param<tab>launchNumber<tab>returnLocation?re
       turnParam1=395&anotherReturnParam=Yes&Return=OK

[0076] With the stack in this state, application “BBB” launches application “AAA” and terminates itself. Upon startup, application “AAA” will check the top of the stack, see that it is being launched to return from its call to function “foo”. Application “AAA” may then use the launch parameters to restore state, read the return value, and proceed accordingly.

[0077] Conclusion

[0078] This concludes the description of one or more embodiments of the invention. The following describes some alternative embodiments for accomplishing the present invention.

[0079] For example, any type of personal digital assistant or computer, such as a mainframe, minicomputer, or personal computer, or computer configuration, such as a timesharing mainframe, local area network, standalone personal computer, WINCE device, etc. could be used with the present invention.

[0080] The foregoing description of one or more embodiments of the invention has been presented for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form disclosed. Many modifications and variations are possible in light of the above teaching. It is intended that the scope of the invention be limited not by this detailed description, but rather by the claims appended hereto.

Claims

1. A method for collaborating applications executing on a personal digital assistant (PDA) comprising: obtaining a shared database on the PDA to be used as a common stack for collaborating applications; storing one or more program entry records in the database wherein the last program entry record stored is the top of the stack, and wherein each program entry record comprises information regarding an application launched on the PDA; and popping the last program entry record off of the stack when a second application corresponding to the last program entry record has completed execution, wherein the popping of the last program entry record returns control to a first application corresponding to a next program entry record on the stack.

2. The method of claim 1 further comprising storing a record number in the database, wherein the record number comprises a number of record entries in the stack.

3. The method of claim 2 further comprising verifying the stack using the record number.

4. The method of claim 1 wherein the information for a program entry record comprises a name of an application launched on the PDA and optional parameters for the application.

5. The method of claim 1 wherein the information for a program entry record comprises state information regarding an application launched on the PDA, and wherein the state information may be used to restore the state of the application.

6. The method of claim 1 wherein: a first program entry record in the database comprises information regarding a first application launched on the PDA; and a second program entry record in the database comprises information regarding a second application launched by the first application on the PDA.

7. The method of claim 6 wherein the second program entry record is popped from the stack by the second application.

8. The method of claim 1 wherein popping the last program entry record further comprises storing return values, from the application that has completed execution, with the next program entry record on the stack.

9. The method of claim 1 wherein the storing of a program entry record comprises storing context parameters for the second application to be launched.

10. A system for collaborating applications executing on a personal digital assistant (PDA) comprising: (a) a personal digital assistant (PDA); (b) a shared database on the PDA that is used as a common stack for collaborating applications launched on the PDA; (c) a program entry record stored in the shared database wherein a last program entry record stored in the database is the top of the stack, and wherein each program entry record comprises information regarding an application launched on the PDA; (c) an application launched on the PDA, the application configured to: (i) store the program entry record in the shared database; and (ii) pop the last program entry record off of the stack when the application has completed execution, wherein the popping of the last program entry record returns control to a next application corresponding to a next program entry record on the stack.

11. The system of claim 10 further comprising a record number stored in the database, wherein the record number comprises a number of record entries in the stack.

12. The system of claim 11 wherein the record number is used to verify the stack.

13. The system of claim 10 wherein the information for a program entry record comprises a name of an application launched on the PDA and optional parameters for the application.

14. The system of claim 10 wherein the information for a program entry record comprises state information regarding an application launched on the PDA, and wherein the state information may be used to restore the state of the application.

15. The system of claim 10 wherein: a first program entry record in the database comprises information regarding a first application launched on the PDA; and a second program entry record in the database comprises information regarding a second application launched by the first application on the PDA.

16. The system of claim 15 wherein the second program entry record is popped from the stack by the second application.

17. The system of claim 10 wherein the popping the last program entry record by the application further comprises storing return values, from the application that has completed execution, with the next program entry record on the stack.

18. The system of claim 10 wherein the program entry record comprises context parameters for an application to be launched.

19. An article of manufacture for collaborating applications executing on a personal digital assistant (PDA) comprising: means for obtaining a shared database on the PDA to be used as a common stack for collaborating applications; means for storing one or more program entry records in the database wherein the last program entry record stored is the top of the stack, and wherein each program entry record comprises information regarding an application launched on the PDA; and means for popping the last program entry record off of the stack when a second application corresponding to the last program entry record has completed execution, wherein the popping of the last program entry record returns control to a first application corresponding to a next program entry record on the stack.

20. The article of manufacture of claim 19 further comprising means for storing a record number in the database, wherein the record number comprises a number of record entries in the stack.

21. The article of manufacture of claim 20 further comprising means for verifying the stack using the record number.

22. The article of manufacture of claim 19 wherein the information for a program entry record comprises a name of an application launched on the PDA and optional parameters for the application.

23. The article of manufacture of claim 19 wherein the information for a program entry record comprises state information regarding an application launched on the PDA, and wherein the state information may be used to restore the state of the application.

24. The article of manufacture of claim 19 wherein: a first program entry record in the database comprises information regarding a first application launched on the PDA; and a second program entry record in the database comprises information regarding a second application launched by the first application on the PDA.

25. The article of manufacture of claim 24 further comprising means for popping the second program entry record from the stack by the second application.

26. The article of manufacture of claim 19 wherein the means for popping the last program entry record further comprises means for storing return values, from the application that has completed execution, with the next program entry record on the stack.

27. The article of manufacture of claim 19 wherein the means for storing of a program entry record comprises means for storing context parameters for the second application to be launched.

28. A method for collaborating applications executing on a computer comprising: obtaining a shared database on the computer to be used as a common stack for collaborating applications; storing one or more program entry records in the database wherein the last program entry record stored is the top of the stack, and wherein each program entry record comprises information regarding an application launched on the computer; and popping the last program entry record off of the stack when a second application corresponding to the last program entry record has completed execution, wherein the popping of the last program entry record returns control to a first application corresponding to a next program entry record on the stack.