Computer-implemented method, system, and computer program (multi-user debugging with user data isolation)

Abstract

To provide a computer-implemented method, system, and computer program product for multi-user debugging with use data isolation.SOLUTION: The method includes receiving a first request from a first developer to initiate a debug of a program and receiving a second request from a second developer to initiate the debug of the program. The method further includes, responsive to receiving the first request and the second request, initiating the debug of the program. The method further includes sending first source code for the program to the first developer, wherein the first source code is associated with the first developer. The method further includes sending second source code for the program to the second developer, wherein the second source code is associated with the second developer. The method further includes updating the program responsive to receiving a change to at least one of the first source code or the second source code.SELECTED DRAWING: Figure 4

Description

[Technical Field]

[0001] TECHNICAL FIELD Embodiments described herein relate generally to processing systems, and more particularly to multi-user debugging with user data isolation. [Background technology]

[0002] Complex computer software programs can be divided into several layers of logical functionality, one or more of which are subdivided into different components. These components run simultaneously to accomplish a specific function. In some cases, these components are developed by different companies. However, they may also be developed by the same company but within different departments. Summary of the Invention [Problem to be solved by the invention]

[0003] A computer-implemented method, system, and computer program product for multi-user debugging with user data isolation is provided. [Means for solving the problem]

[0004] A non-limiting exemplary computer-implemented method includes receiving a first request from a first developer to begin debugging of the program and receiving a second request from a second developer to begin the debugging of the program. The method further includes initiating the debugging of the program in response to receiving the first request and the second request. The method further includes sending first source code of the program to the first developer, the first source code being associated with the first developer. The method further includes sending second source code of the program to the second developer, the second source code being associated with the second developer. The method further includes updating the program in response to receiving changes to at least one of the first source code or the second source code.

[0005] A non-limiting exemplary computer-implemented method improves the programs being debugged and the computing system(s) on which they are running by providing a multi-user debugging environment and providing data protection through isolation, allowing multi-user debugging while providing developers with access only to their respective portions of the code. This protects the source code of the programs being debugged. Developers from different companies / organizations can debug a function sequentially, improving problem resolution efficiency.

[0006] In addition to or as an alternative to one or more features described herein, further embodiments of the method may include the first request including a first user debug credential associated with the first developer. In addition to or as an alternative to one or more features described herein, further embodiments of the method may include determining, prior to sending the first source code of the program to the first developer, whether the first developer is authorized to access the first source code of the program based on the first user debug credential. The user debug credential enables developer authority control over respective portions of source code.

[0007] In addition to or as an alternative to one or more features described herein, further embodiments of the method may include the second request including a second user debug credential associated with the second developer. In addition to or as an alternative to one or more features described herein, further embodiments of the method may further include, prior to sending the second source code of the program to the second developer, determining whether the second developer is authorized to access the second source code of the program based on the second user debug credential. The user debug credential enables developer authority control over respective portions of source code.

[0008] Other embodiments of the present invention implement features of the above-described methods in computer systems and computer program products.

[0009] Further technical features and advantages are realized through the techniques of the present invention. Embodiments and aspects of the present invention are described in detail herein and are considered a part of the claimed subject matter. For a better understanding, reference is made to the detailed specification and drawings.

[0010] The particulars of the exclusive rights set forth herein are particularly pointed out and distinctly claimed in the claims at the conclusion of the specification. The above-discussed and other features and advantages of embodiments of the present invention will become apparent from the following detailed description taken in conjunction with the accompanying drawings. [Brief explanation of the drawings]

[0011] [Figure 1] FIG. 1 is a block diagram of a system for multi-user debugging with user data isolation according to an aspect of the present disclosure. [Figure 2A] FIG. 2A is a diagram illustrating a table of stack calls that cause errors, according to one or more embodiments described herein. [Figure 2B] FIG. 2B is a diagram illustrating a table of program names and corresponding component names according to one or more embodiments described herein. [Figure 2C] FIG. 2C is a diagram illustrating a table of program names and corresponding component names with associated ownership / access rights for each component, according to one or more embodiments described herein. [Figure 3A] FIG. 3A is a diagram illustrating an example of the system of FIG. 1 in accordance with one or more embodiments described herein. [Figure 3B] FIG. 3B is a diagram illustrating an example of the system of FIG. 1 in accordance with one or more embodiments described herein. [Figure 4] FIG. 4 is a flowchart illustrating a method for data separation with source code control according to one or more embodiments described herein. [Figure 5] FIG. 5 is a diagram illustrating a cloud computing environment in accordance with one or more embodiments described herein. [Figure 6] FIG. 6 is a diagram illustrating abstraction model layers according to one or more embodiments described herein. [Figure 7] FIG. 7 is a block diagram of a processing system for implementing the presently described techniques in accordance with one or more embodiments described herein.

[0012] The diagrams shown herein are exemplary. There may be many variations in the diagrams or the operations described therein without departing from the scope of the invention. For example, actions may be performed in a different order, or actions may be added, deleted, or modified. Additionally, the term "coupled," and variations thereof, indicates that there is a communication path between two elements, and does not imply a direct connection between elements with no intervening elements / connections between them. All of these variations are considered part of the specification. DETAILED DESCRIPTION OF THE INVENTION

[0013] One or more embodiments of the present invention provide multi-user debugging with isolation of user data.

[0014] Complex computer software programs can be divided into several layers of logical functionality, one or more of which are subdivided into different components. These components run simultaneously to accomplish a specific function. In some cases, these components are developed by different companies. However, they may even be developed by the same company, but belong to different departments. Due to the need for source code permission management, developers often only have access to the program code for their own company's / department's components.

[0015] When there is a problem with a program, it is useful to reproduce the problem and identify which (one or more) components caused the problem. However, sometimes the problem can only be reproduced in a specific environment. Each component related to the problematic functionality needs to work together to identify the scope of the problem. However, debugging each component individually not only takes time to reproduce the problem, but also increases the communication load between components, as some components do not easily store intermediate states between them.

[0016] The above-described aspects of the present invention address the shortcomings of the prior art by providing a multi-user debug environment across components using a debug manager module. The multi-user debug environment described herein allows developers with different components to sequentially debug functions while providing local visibility of code across components based on privilege control. The multi-user debug environment improves communication efficiency between developers, saving communication time and satisfying code privilege control. The multi-user debug environment also provides data protection through isolation, enabling multi-user debugging while allowing developers to access only their respective portions of code, thereby improving the programs being debugged and the computing systems on which they operate. This protects the source code of the programs being debugged. Developers from different companies / organizations can sequentially debug a function, improving problem resolution efficiency.

[0017] Turning now to FIG. 1 , a block diagram of a system 100 for multi-user debugging with user data isolation is shown, according to an aspect of the present disclosure. System 100 includes a processing system 110, a debug manager engine 120, and debug clients 131, 132, and 133 (collectively referred to as “debug clients 130”). While three debug clients 131-133 are shown, fewer or additional debug clients may be implemented in other embodiments, and the present technology is not limited to the specific number of debug clients shown. System 100 provides for sequential debugging of a complex program (e.g., program 116) in a single debug session among multiple users (e.g., debug clients 130) with source code and run-time address authority control.

[0018] Processing system 110 includes a processing unit 112 and a memory 114. Processing unit 112 may be any suitable processing unit(s), such as one or more processors 721 of processing system 700 of FIG. 7, and memory 114 may be any suitable memory, such as RAM 724 or ROM 722 of processing system 700 of FIG. 7. Memory 114 is an example of a computer-readable storage medium that may store a program 116 as instructions (e.g., computer-readable program instructions) that, when executed by processing unit 112, cause operations to be performed.

[0019] During software development of program 116, it may be desirable to debug program 116, such as when errors or "bugs" occur. Debugging is the act of finding and correcting glitches or problems that arise during the execution of a program such as program 116.

[0020] In the embodiment shown in FIG. 1 , a debug manager engine 120 is provided that supports debugging. According to one or more embodiments described herein, the debug manager engine 120 provides access (or ownership) to different components to allow users / developers to sequentially debug functions using respective debug clients 130 while providing local visibility of the code between the components based on privilege control. According to one or more embodiments described herein, the debug manager engine 120 can communicate with the processing system 110 and the debug clients 130. The debug clients 130 may be any suitable device or system that allows a user to perform debugging, such as a laptop computer, a desktop computer, a mobile phone, a tablet computer, etc. The debug manager engine 120 provides user data isolation based on privilege control by providing user debug credentials that provide developers with appropriate permissions to view and debug the source code of the program 116, examine and modify the contents of specific memory addresses, etc.

[0021] In one example, debug manager engine 120 may be incorporated into (or in conjunction with) processing system 110 such that processing system 110 implements (using processing unit 112 and memory 114) debug manager engine 120. In another example, debug manager engine 120 may be implemented in a processing system (not shown) separate from processing system 110.

[0022] The various components, modules, engines, etc. described with respect to FIG. 1 may be implemented as instructions stored on a computer-readable storage medium, as hardware modules, as special-purpose hardware (e.g., application-specific hardware, application-specific integrated circuits (ASICs), application-specific processors (ASSPs), field-programmable gate arrays (FPGAs), embedded controllers, hardwired circuitry, etc.), or as some combination or combinations thereof. According to aspects of the present disclosure, the engine(s) described herein may be a combination of hardware and programming. The programming may be processor-executable instructions stored on a tangible memory, and the hardware may include a processing unit 112 for executing those instructions. Thus, a system memory (e.g., memory 114) may store program instructions that, when executed by the processing unit 112, implement the engines described herein (e.g., program 116, debug manager engine 120, etc.). Other engines may also be utilized to include other features and functionality described in other examples herein.

[0023] 2A-2C are now described, which relate to components of a program (e.g., program 116) being debugged in accordance with one or more embodiments described herein. In the example of FIGS. 2A-2C, components Component1, Component2, and Component3 are executing together on processing system 110 to complete a particular function. However, during execution, program 116 encounters error 201 issued from Component3_Procedure2. An example call stack 200 that caused error 201 is shown in the table of FIG. 2, in accordance with one or more embodiments described herein.

[0024] Each row in the table represents information about the call stack 200, including which components and procedures were called. For example, the call stack 200 starts with Component1_Procedure1, which calls Component1_Procedure2, which calls Component2_Procedure1. Component2_Procedure1 calls Component3_Procedure1, which calls Component3_Procedure2. In this way, the components / procedures are related to each other through their respective calls.

[0025] 2B is a diagram illustrating a table 210 of program names and corresponding component names, according to one or more embodiments described herein. In this example, Component1_Procedure1 and Component1_Procedure2 correspond to Component 1, Component2_Procedure1 corresponds to Component 2, and Component3_Procedure1 and Component3_Procedure2 correspond to Component 3. Each component has different permissions to access its respective source code, as described with reference to FIG. 2C.

[0026] In particular, Figure 2C is a diagram illustrating a table 210 of program names and corresponding component names, along with the associated ownership / access rights for each component, according to one or more embodiments described herein. That is, each of the components is accessible (or owned) by a developer of developers 220. In this example, component 1 is accessible (or owned) by developer 221, component 2 is accessible (or owned) by developer 222, and component 3 is accessible (or owned) by developer 223. In other words, as shown in Figure 2C, each of developers 220 has permissions to the components.

[0027] When debugging, it is useful to reproduce the problem to determine which component(s) / procedure(s) caused the problem. Each component related to the problematic function (the function being debugged) needs to work together to determine the scope of the problem. However, when each component is debugged separately, it is not easy to save intermediate states between components, which increases the communication load between components. This difficulty arises especially when different developers are involved in different accesses to the components. For example, the first developer (e.g., one developer can only access component 1, while the second developer can only access components 2 and 3) can access the first component.

[0028] To initiate debugging, one or more developers 220 send debug requests for their respective component(s) to debug manager engine 120. This is shown in the example of FIG. 3A, where developer 221, developer 222, and developer 223 each use their respective debug clients 131, 132, and 133 to send debug requests 301, 302, and 303 for their respective components to debug manager engine 120 (as shown in FIG. 2B). Each request includes a developer user debug credential. For example, developer 221 has user debug credential 311, which is included in or with debug request 301. Similarly, developer 222 has user debug credential 312, which is included in or with debug request 302 and 303, respectively, and developer 223 has user debug credential 313, which is included in or with debug request 303.

[0029] Debug manager engine 120 receives debug requests 301, 302, and 303 along with user debug credentials 311, 312, and 313, as shown. That is, developer 221, developer 222, and developer 223 each use their respective debug client 130 to put their respective components (e.g., component 1, component 2, and component 3) of program 116 into debug. Debugging begins when each of developer 221, developer 222, and developer 223 initiates debugging. Debug manager engine 120 transmits source code to each developer (e.g., developer 221, developer 222, and developer 223) in accordance with their respective debug requests 301, 302, and 303 and their respective user debug credentials 311, 312, and 313. Thus, developer 221 views the source code for component 1 (i.e., the component of program 116 associated with developer 221), developer 222 views the source code for component 2 (i.e., the component of program 116 associated with developer 222), and developer 223 views the source code for component 3 (i.e., the component of program 116 associated with developer 223). Each developer is then presented with a debug interface such as that shown in FIG. 3B on the display of their respective debug client 130. For example, developer 221 is presented with debug interface 321 for component 1, developer 222 is presented with debug interface 322 for component 2, and developer 223 is presented with debug interface 323 for component 3. One or more developers 220 can then modify their respective source code and update the programs to fix bugs.

[0030] FIG. 4 is a flowchart illustrating a method 400 for data isolation with source code control according to one or more embodiments described herein. Method 400 is described with reference to system 100 as shown in FIGS. 1, 3A, and 3B, but is not limited thereto, and any suitable system, device, or combination thereof can be used to implement method 400. For example, method 400 can be implemented by any suitable device(s) and / or system(s), such as processing system 110 and / or debug manager engine 120 of FIGS. 1, 3A, and 3B, processing system 700 of FIG. 7, or any other suitable device(s) and / or system(s), or combination thereof. Method 400 is useful, for example, when different components (e.g., component 1, component 2, component 3) are in the same call stack (e.g., see FIG. 2A) but have different address scopes.

[0031] In block 402, a developer (e.g., one of developers 220) sends a request to debug manager engine 120 to check the contents of the specified address with a length. For example, developer 221 associated with debug client 131 sends the request from debug client 131 to debug manager engine 120. It should be understood that multiple developers can send requests to debug manager engine 120 simultaneously, in parallel, or at different times.

[0032] In block 404, the debug manager engine 120 sends the specified address and length to the debug server engine 118, requesting the component name (eg, component 1 for developer 221).

[0033] In block 406 , the debug server engine 118 returns the component name of the address with the length to the debug manager engine 120 .

[0034] At block 408, the debug manager engine 120 checks whether the requesting developer (e.g., developer 221) is authorized to access / modify the component (e.g., component 1). If the requesting developer (e.g., developer 221) is not authorized to access / modify the component (e.g., component 1), at block 410, an indication (e.g., message) of lack of authorization is returned to the debug client associated with the developer (e.g., debug client 131 associated with developer 221).

[0035] On the other hand, if the requesting developer is determined to be authorized at block 408, the method 400 proceeds to block 412, where the specified address and length are sent by the debug manager engine 120 back to the debug server engine 118 to request the contents of the component (e.g., component 1).

[0036] In block 414, the debug server engine 118 returns the contents of the address to the debug manager engine 120, which then returns the contents of the address to the debug client 131 (e.g., debug client 131) that originated the request in block 416.

[0037] It should be understood that additional steps may be included, and that the steps shown in FIG. 4 are exemplary, and that other steps may be added, and existing steps may be deleted, modified, or rearranged, without departing from the scope of the present disclosure.

[0038] Continuing with reference to FIG. 3B, system 100 using debug manager engine 120 can implement one or more digital certificate manager (DCM) application programming interfaces (APIs). For example, one or more DCM APIs can be implemented in debug manager engine 120 to automate certificate management without using the DCM browser-based interface. Applications written using these DCM APIs can update certificates present in the system certificate store, update application definitions to use the updated certificates, and update trust lists with certificate authorities that issued the updated certificates. The DCM APIs can, for example, associate X.509 certificates with user profiles, and can also use other suitable certificates for such purposes. The APIs can add, delete, list, and search certificates associated with a user profile (e.g., the profile of developer 220).

[0039] System 100 may also use one or more of debug clients 130 to implement a user debug certificate module that provides the following functionality: the ability to call DCM APIs to add, remove, or update, or a combination of, certificate assignments for debug server engine 118; the ability to call DCM APIs to retrieve and verify certificate assignment information for debug server engine 118;

[0040] The certificates (e.g., user debug certificates 311-313) may include information such as the respective developer's user profile, module / program / service program name, expiration date, etc. The debug manager engine 120 may, for example, validate the certificate before providing access to source code and / or data logging.

[0041] Although this disclosure includes detailed descriptions of cloud computing, implementation of the teachings described herein is not limited to cloud computing environments. Rather, embodiments of the invention can be practiced in conjunction with any other type of computing environment now known or later developed.

[0042] Cloud computing is a service delivery model for enabling convenient, on-demand network access to a shared pool of configurable computing resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) that can be rapidly provisioned and released with minimal management effort or interaction with the service provider. This cloud model may include at least five characteristics, at least three service models, and at least four implementation models.

[0043] The characteristics are as follows:

[0044] On-Demand Self-Service: Cloud consumers can unilaterally provision computing capacity, such as server time or network storage, automatically as needed, without the need for human interaction with the service provider.

[0045] Broad network access: Computing power is available over the network and can be accessed through standard mechanisms, facilitating use by heterogeneous thin or thick client platforms (e.g., cell phones, laptops, PDAs).

[0046] Resource Pooling: Computing resources from a provider are pooled and offered to multiple consumers using a multi-tenant model. Various physical and virtual resources are dynamically allocated and reallocated based on demand. Consumers generally have no control or knowledge of the exact location of the resources they are provided with, so there is a sense of location independence. However, consumers may be able to identify their location at a higher level of abstraction (e.g., country, state, data center).

[0047] Rapid Elasticity: Computing capacity can be provisioned quickly and elastically, sometimes automatically, to instantly scale out and quickly released to instantly scale in. To the consumer, the computing power available to provision often appears unlimited, and can be purchased at any time and in any quantity.

[0048] Metered Services: Cloud systems leverage measurement capabilities at some level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, active user count) to automatically control and optimize resource usage. Resource usage can be monitored, controlled, and reported to provide transparency to both providers and consumers of utilized services.

[0049] The service model is as follows:

[0050] Software as a Service (SaaS): The functionality offered to the consumer is the availability of a provider's applications running on a cloud infrastructure. The applications can be accessed from a variety of client devices through a thin-client interface such as a web browser (e.g., webmail). The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or even individual application functions, except for limited user-specific application configuration settings.

[0051] Platform as a Service (PaaS): The capability offered to consumers is to deploy applications they create or acquire onto a cloud infrastructure using programming languages ​​and tools supported by the provider. The consumer does not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but does have control over the deployed applications and, in some cases, the configuration of their hosting environment.

[0052] Infrastructure as a Service (IaaS): The functionality provided to consumers is the provisioning of processors, storage, networking, and other basic computing resources on which the consumer can deploy and run any software, including operating systems and applications. The consumer does not manage or control the underlying cloud infrastructure, but has control over the operating systems, storage, and deployed applications, and in some cases partial control over some network components (e.g., host firewalls).

[0053] The deployment model is as follows:

[0054] Private Cloud: This cloud infrastructure is dedicated to a specific organization and can be managed by that organization or a third party, and can exist on-premise or off-premise.

[0055] Community Cloud: This cloud infrastructure is shared by multiple organizations to support a specific community with common concerns (e.g., mission, security requirements, policies, and compliance). This cloud infrastructure can be managed by those organizations or a third party and can exist on-premises or off-premises.

[0056] Public cloud: This cloud infrastructure is available to the general public or large industry organizations and is owned by an organization that sells cloud services.

[0057] Hybrid cloud: This cloud infrastructure combines two or more cloud models (private, community, or public), each of which retains its inherent nuances but is bound by standards or specific technologies that enable data and application portability (e.g., cloud bursting for load balancing between clouds).

[0058] A cloud computing environment is a service-oriented environment that emphasizes statelessness, low coupling, modularity, and semantic interoperability. At the core of cloud computing is an infrastructure that includes a network of interconnected nodes.

[0059] FIG. 5 illustrates an exemplary cloud computing environment 50. As illustrated, the cloud computing environment 50 includes one or more cloud computing nodes 10, with which local computing devices used by cloud consumers (e.g., PDAs or cell phones 54A, desktop computers 54B, laptop computers 54C, or automobile computer systems 54N, or combinations thereof) can communicate. The nodes 10 can communicate with each other. The nodes 10 can be physically or virtually grouped (not shown) in one or more networks, such as the private, community, public, or hybrid clouds described above, or combinations thereof. This enables the cloud computing environment 50 to provide infrastructure, platform, or software as a service, or combinations thereof, for which cloud consumers are not required to maintain resources on their local computing devices. It should be understood that the types of computing devices 54A-N illustrated in FIG. 5 are merely exemplary, and that the computing nodes 10 and the cloud computing environment 50 can communicate with any type of electronic device via any type of network or network-addressable connection (e.g., using a web browser), or both.

[0060] Next, a set of functional abstraction layers provided by the cloud computing environment 50 (FIG. 5) is shown in FIG. 6. It should be understood in advance that the components, layers, and functions shown in FIG. 6 are merely exemplary, and embodiments of the present invention are not limited thereto. As shown, the following layers and corresponding functions are provided:

[0061] Hardware and software layer 60 includes hardware and software components. Examples of hardware components include mainframe 61, reduced instruction set computer (RISC) architecture-based server 62, server 63, blade server 64, storage device 65, and network and network components 66. In some embodiments, software components include network application server software 67 and database software 68.

[0062] The virtualization layer 70 provides an abstraction layer from which virtual entities such as virtual servers 71, virtual storage 72, virtual networks including virtual private networks 73, virtual applications and operating systems 74, and virtual clients 75 can be provided.

[0063] By way of example, the management layer 80 may provide the following functionality: Resource provisioning 81 enables dynamic procurement of computing and other resources utilized to execute tasks within the cloud computing environment. Metering and pricing 82 enables cost tracking as resources are utilized within the cloud computing environment and billing or invoicing for the consumption of these resources. By way of example, these resources may include application software licenses. Security enables identification and verification of cloud consumers and tasks, as well as protection for data and other resources. User portal 83 provides consumers and system administrators with access to the cloud computing environment. Service level management 84 enables allocation and management of cloud computing resources so that requested service levels are met. Service level agreement (SLA) planning and fulfillment 85 enables advance arrangement and procurement of anticipated future cloud computing resources required in accordance with SLAs.

[0064] The workload layer 90 provides examples of functionality available in a cloud computing environment. Examples of workloads and functionality that can be provided from this layer include mapping and navigation 91, software development and lifecycle management 92, virtual classroom instruction delivery 93, data analytics processing 94, transaction processing 95, and debugging programs 96.

[0065] It will be appreciated that one or more embodiments described herein can be implemented in conjunction with any other type of computing environment now known or later developed. For example, FIG. 7 is a block diagram of a processing system 700 for implementing the techniques described herein. In accordance with one or more embodiments described herein, the processing system 700 is an example of the cloud computing node 10 of FIG. 5. In the example, the processing system 700 includes one or more central processing units (“processors” or “processing resources”) 721 a, 721 b, 721 c, etc. (collectively or generically referred to as the processor(s) 721 or the processing units(s), or both). In aspects of the present disclosure, each processor 721 may include a reduced instruction set computer (RISC) microprocessor. The processors 721 are coupled to system memory (e.g., random access memory (RAM) 724) and various other components via a system bus 733. A read-only memory (ROM) 722 is coupled to the system bus 733 and may include a basic input / output system (BIOS) that controls certain basic functions of the processing system 700.

[0066] Also depicted are an input / output (I / O) adapter 727 and a network adapter 726 coupled to the system bus 733. The I / O adapter 727 may be a small computer system interface (SCSI) adapter that communicates with a hard disk 723 or storage device 725, or both, or other similar components. The I / O adapter 727, hard disk 723, and storage device 725 are collectively referred to herein as a mass storage device 734. An operating system 740 for executing on the processing system 700 may be stored on the mass storage device 734. The network adapter 726 interconnects the system bus 733 with an external network 736, enabling the processing system 700 to communicate with other such systems.

[0067] A display (e.g., a display monitor) 735 is connected to the system bus 733 by a display adapter 732, which may include a graphics adapter and a video controller to improve performance of graphics-intensive applications. In one aspect of the present disclosure, adapters 726, 727, and / or 732 may be connected to one or more I / O buses that are connected to the system bus 733 via an intermediate bus bridge (not shown). Suitable I / O buses for connecting peripheral devices such as hard disk controllers, network adapters, and graphics adapters typically include common protocols such as Peripheral Component Interconnect (PCI). Additional input / output devices are shown connected to the system bus 733 via a user interface adapter 728 and a display adapter 732. A keyboard 729, a mouse 730, and speakers 731 may be interconnected to the system bus 733 via a user interface adapter 728, which may include, for example, a super I / O chip that integrates multiple device adapters into a single integrated circuit.

[0068] In some aspects of the present disclosure, the processing system 700 includes a graphics processing unit 737. The graphics processing unit 737 is a specialized electronic circuit designed to manipulate and modify memory to accelerate the creation of images in a frame buffer intended for output to a display. In general, the graphics processing unit 737 is very efficient at operating on computer graphics and image processing, and its highly parallel structure makes it more effective than a general-purpose CPU at algorithms in which the processing of large blocks of data is performed in parallel.

[0069] Thus, as configured herein, processing system 700 includes processing capability in the form of processor 721, storage capability including system memory (e.g., RAM 724) and mass storage device 734, input means such as keyboard 729 and mouse 730, and output capability including speaker 731 and display 735. In some embodiments of the present disclosure, a portion of the system memory (e.g., RAM 724) and mass storage device 734 collectively store an operating system 740, such as the AIX® operating system from IBM Corporation, for coordinating the functions of the various components shown in processing system 700.

[0070] Various embodiments of the present invention are described herein with reference to the associated drawings. Alternate embodiments of the present invention may be devised without departing from the scope of the present invention. In the following description and in the drawings, various connections and relationships (e.g., above, below, adjacent, etc.) between elements are shown. These connections and / or relationships may be direct or indirect unless otherwise specified, and the present invention is not intended to be limited in this respect. Thus, coupling of entities may refer to either direct or indirect coupling, and relationships between entities may be direct or indirect. Furthermore, various tasks and process steps described herein may be combined into a more comprehensive procedure or process having additional steps or functions not specifically described herein.

[0071] The following definitions and abbreviations are used in interpreting the claims and the specification. As used herein, the terms "comprises," "comprising," "includes," "including," "has," "having," "contains," "containing," or any other variation thereof, are exclusive inclusions. For example, a composition, mixture, process, method, article, or device that includes a list of elements is not necessarily limited to only those elements, but may include other elements not expressly listed in such composition, mixture, process, method, article, or device.

[0072] Additionally, the term "exemplary" is used herein to mean "serving as an example, instance, or illustration." Any embodiment or design described herein as "exemplary" is not necessarily to be construed as preferred or advantageous over other embodiments or designs. The terms "at least one" and "one or more" are understood to include one or more, i.e., any integer number such as 1, 2, 3, 4, etc. The term "plurality" is understood to include two or more, i.e., any integer number such as 2, 3, 4, 5, etc. The term "connected" can include both indirect and direct "connections."

[0073] The terms "about," "substantially," "approximately," and variations thereof are intended to include the degree of error associated with measurement of a particular quantity based on equipment available at the time of filing. For example, "about" can include a range of ±8%, 5%, or 2% of a particular value.

[0074] For the sake of brevity, conventional techniques related to making and using aspects of the present invention may or may not be described in detail herein. In particular, various aspects of computing systems and specific computer programs for implementing various technical features described herein are well known. Thus, for the sake of brevity, many conventional implementation details are only briefly mentioned herein or are omitted entirely without providing details of well-known systems and / or processes.

[0075] The present invention may be a system, method, or computer program product, or combination thereof, integrated at any possible level of technical detail. The computer program product may include a computer-readable storage medium having stored thereon computer-readable program instructions for causing a processor to carry out aspects of the present invention.

[0076] A computer-readable storage medium may be a tangible device capable of retaining and storing instructions for use by an instruction execution device. The computer-readable storage medium may be, by way of example, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or a suitable combination thereof. More specific examples of computer-readable storage media include portable computer diskettes, hard disks, RAM, ROM, EPROM (or flash memory), SRAM, CD-ROMs, DVDs, memory sticks, floppy disks, mechanically encoded devices having instructions recorded on punch cards or ridge-in-groove structures, or the like, and suitable combinations thereof. Computer-readable storage devices, as used herein, should not be construed as ephemeral signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or electrical signals transmitted over wires.

[0077] The computer-readable program instructions described herein can be downloaded from a computer-readable storage medium to each computer / processing device. Alternatively, they can be downloaded to an external computer or external storage device via a network (e.g., the Internet, a LAN, a WAN, or a wireless network, or a combination thereof). The network can include copper transmission cables, optical fiber transmissions, wireless transmissions, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface within each computer / processing device receives the computer-readable program instructions from the network and transfers the computer-readable program instructions to a computer-readable storage medium in the respective computer / processing device for storage.

[0078] The computer-readable program instructions for carrying out the operations of the present invention can be either assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine-dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuits, or source or object code written in any combination of one or more programming languages, including object-oriented programming languages ​​such as Smalltalk and C++, and procedural programming languages ​​such as the "C" programming language and similar programming languages. The computer-readable program instructions can execute entirely on the user's computer as a stand-alone software package, partially on the user's computer, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network, including a LAN or WAN, or may be connected to an external computer (e.g., via the Internet using an Internet Service Provider). In some embodiments, electronic circuitry, including, for example, programmable logic circuits, field programmable gate arrays (FPGAs), programmable logic arrays (PLAs), can execute computer-readable program instructions by utilizing state information of the computer-readable program instructions to customize the electronic circuitry for carrying out aspects of the present invention.

[0079] Aspects of the present invention are described herein with reference to flowchart and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. Each block of the flowchart and / or block diagrams, and combinations of blocks in the flowchart and / or block diagrams, can be implemented by computer-readable program instructions.

[0080] The computer-readable program instructions may be provided to a processor of a general-purpose computer, special-purpose computer, or other programmable data processing apparatus to produce a machine, whereby the instructions, executed by the processor of such computer or other programmable data processing apparatus, create means for performing the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams. The computer-readable program instructions may also be stored on a computer-readable storage medium that can instruct a computer, programmable data processing apparatus, or other device, or combination thereof, to function in a particular manner. The computer-readable storage medium having instructions stored thereon thereby constitutes an article of manufacture including instructions for performing aspects of the functions / acts specified in one or more blocks of the flowcharts and / or block diagrams.

[0081] Computer-readable program instructions may also be loaded into a computer, other programmable device, or other device and a series of operational steps executed on the computer, other programmable device, or other device to create a computer-implemented process, whereby the instructions executing on the computer, other programmable device, or other device perform the functions / operations identified in one or more blocks in the flowcharts and / or block diagrams.

[0082] The flowcharts and block diagrams in the figures of this disclosure illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of instructions, including one or more executable instructions for performing a specific logical function. In some other implementations, the functions shown in the blocks may be executed in a different order than shown in the figures. For example, two blocks shown in succession may actually be executed substantially simultaneously or in reverse order, depending on the functionality involved. Note that each block in the block diagrams and / or flowcharts, and combinations of blocks in the block diagrams and / or flowcharts, may be implemented by a dedicated hardware-based system that performs the specified function or operation, or by a combination of dedicated hardware and computer instructions.

[0083] The description of various embodiments of the present invention is presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. It will be apparent to those skilled in the art that many modifications and variations are possible without departing from the scope of the described embodiments. The terms used herein have been selected to best explain the principles of the embodiments, practical applications or technical improvements to technology found in the market, or to enable those skilled in the art to understand the embodiments described herein.

Claims

1. 1. A computer-implemented method for multi-user debugging of a program, the method comprising: receiving a first request from a first developer to begin debugging the program; receiving a second request from a second developer to initiate the debugging of the program; initiating the debugging of the program in response to receiving the first request and the second request; transmitting a first source code of the program to the first developer, the first source code being associated with the first developer; transmitting second source code of the program to the second developer, the second source code being associated with the second developer; updating the program in response to receiving changes to at least one of the first source code or the second source code; 11. A computer-implemented method comprising:

2. the first request includes a first user debug credential associated with the first developer; The computer-implemented method of claim 1 .

3. determining, before transmitting the first source code of the program to the first developer, whether the first developer is authorized to access the first source code of the program based on the first user debug certificate; The computer-implemented method of claim 2 further comprising:

4. the first source code is transmitted to the first developer in response to the first developer determining that the first developer is authorized to access the first source code. The computer-implemented method of claim 3 .

5. the first source code is not transmitted to the first developer in response to determining that the first developer is not authorized to access the first source code. The computer-implemented method of claim 3 .

6. the second request includes a second user debug credential associated with the second developer; The computer-implemented method of claim 1 .

7. determining, before transmitting the second source code of the program to the second developer, whether the second developer is authorized to access the second source code of the program based on the second user debug certificate; The computer-implemented method of claim 6 further comprising:

8. the second source code is transmitted to the second developer in response to the second developer determining that the second developer is authorized to access the second source code. The computer-implemented method of claim 7.

9. the second source code is not transmitted to the second developer in response to determining that the second developer is not authorized to access the second source code. The computer-implemented method of claim 7.

10. a memory containing computer readable instructions; a processor for executing the computer-readable instructions, the computer-readable instructions controlling the processor to: receiving a first request from a first developer to begin debugging a program; receiving a second request from a second developer to initiate the debugging of the program; initiating the debugging of the program in response to receiving the first request and the second request; transmitting a first source code of the program to the first developer, the first source code being associated with the first developer; transmitting second source code of the program to the second developer, the second source code being associated with the second developer; updating the program in response to receiving changes to at least one of the first source code or the second source code; causing an action including system.

11. the first request includes a first user debug credential associated with the first developer; The system of claim 10.

12. determining, before transmitting the first source code of the program to the first developer, whether the first developer is authorized to access the first source code of the program based on the first user debug certificate; The system of claim 11 further comprising:

13. the first source code is transmitted to the first developer in response to the first developer determining that the first developer is authorized to access the first source code. The system of claim 12.

14. the first source code is not transmitted to the first developer in response to determining that the first developer is not authorized to access the first source code. The system of claim 12.

15. the second request includes a second user debug credential associated with the second developer; The system of claim 10.

16. determining, before transmitting the second source code of the program to the second developer, whether the second developer is authorized to access the second source code of the program based on the second user debug certificate; The system of claim 15 further comprising:

17. the second source code is transmitted to the second developer in response to the second developer determining that the second developer is authorized to access the second source code.

17. The system of claim 16.

18. the second source code is not transmitted to the second developer in response to determining that the second developer is not authorized to access the second source code.

17. The system of claim 16.

19. a computer program comprising program instructions, the program instructions being executable by a processor; receiving a first request from a first developer to begin debugging a program; receiving a second request from a second developer to initiate the debugging of the program; initiating the debugging of the program in response to receiving the first request and the second request; transmitting a first source code of the program to the first developer, the first source code being associated with the first developer; transmitting second source code of the program to the second developer, the second source code being associated with the second developer; updating the program in response to receiving changes to at least one of the first source code or the second source code; causing the processor to perform operations including: Computer program.

20. the first request includes a first user debug credential associated with the first developer; the second request includes a second user debug credential associated with the second developer; 20. A computer program according to claim 19.

Images