Abstract: A method, computer program product and system are provided for preloading debug information based on the presence of incremental source code files. Based on parsed input parameters to a source code debugger, a source code repository and a local storage area are searched for an incremental file. In response to the incremental file being located, a preload indicator in the incremental file, which is a source code file, is set. Based on the preload indicator being set, debug symbol data from the incremental file is merged to a preload symbol list. In response to receiving a command to examine the debug symbol data from the incremental file, the preload symbol list is searched for the requested debug symbol data.

Abstract: Embodiments of the present invention provide computer-implemented methods, computer program products and computer systems. Embodiments of the present invention can, in response to receiving performance data associated with records, identify whether the received performance data is associated with long transactions. Embodiments of the present invention can then, in response to determining that the received performance data is associated with long transactions, storing the performance data. Embodiments of the present invention can then classify the stored performance data according to types of transactions the performance data and aggregate the stored performance data based on the classification.

Abstract: A computer-implemented process is disclosed. An application is loaded into a local address space. A request by the application to load a target shared library is intercepted by an interceptor. Using the interceptor and based upon the request being intercepted, a shared library correlation table is searched for a loading count and a loading policy associated with the target shared library. Based upon the loading count and the loading policy, a selection is made between loading the target shared library as a shared library container, and loading the target shared library into the local address space. The target shared library is loaded based upon the selecting. The loading count represents a number of times the target shared library was loaded, and the loading policy indicates how the target shared library is to be loaded.

Abstract: A computer-implemented method includes preprocessing, by a compiler, a plurality of macros in a computer program. Preprocessing a macro includes identifying a compile time condition associated with the macro. Preprocessing the macro further includes determining a current value of the compile time condition at the time of compiling a computer instruction and a previous value of the compile time condition. Preprocessing the macro further includes determining a set of computer instructions enclosed by the macro. The method further includes storing a macro information record that includes the compile time condition, the current value and the previous value of the compile time condition, and an identification of the set of computer instructions enclosed by the macro.

Abstract: Embodiments of the present invention provide computer-implemented methods, computer program products and computer systems. Embodiments of the present invention can, in response to receiving performance data associated with records, identify whether the received performance data is associated with long transactions. Embodiments of the present invention can then, in response to determining that the received performance data is associated with long transactions, storing the performance data. Embodiments of the present invention can then classify the stored performance data according to types of transactions the performance data and aggregate the stored performance data based on the classification.

Abstract: A computer implemented method for debugging computer instructions is provided. The method comprises using a number processors to receive a computer program, including a source code and generate a number of information records associated with a number of computer instructions in the source code, wherein at least one of the computer instructions comprises a function enclosed by a macro. The processors create a data structure based on the information records and generate an index of identifiers in the data structure based on debug information of the computer instructions, wherein the index comprises respective identifying entries for the computer instructions. The processors update information records according to the identifying entries in the data structure.

Abstract: A computer-implemented method includes receiving an initial request from a client, splitting the initial request into a plurality of split requests based on a business logic, acquiring mapping information associated with the plurality of split requests, determining, based, at least in part, on the mapping information, respective split requests included in the plurality of split requests that are candidates for merger into a merged request, merging the respective split requests that are determined to be candidates for merger into one or more merged requests, and sending the one or more merged requests to one or more nodes capable of processing the one or more merged requests.

Abstract: The method of this disclosure may comprise generating a statement invocation relation for a source code by parsing intermediate representation of the source code produced by a compiler. The method of this disclosure may further comprise in response to a first statement in a first code snippet of the plurality of code snippet being changed, determining affected statements in the source code due to the change of the first statement based on the statement invocation relation.

Abstract: Embodiments of the invention include a computer-implemented method that uses a processor to access cryptographic-function constraints associated with an encrypted message. Based on a determination that the cryptographic-function constraints do not include mandatory cryptographic computing resource requirements, first resource-scaling operations are performed that include an analysis of cryptographic metrics associated with a processor. The cryptographic metrics include information associated with the encrypted message, along with performance measurements of cryptographic functions performed by the processor.

Abstract: In an approach, a processor obtains an encrypted data key and a first encrypted protection key from a storage device. A processor sends the first encrypted protection key to a first device. A processor obtains a protection key from the first device, wherein the protection key is generated by the first device through decrypting the first encrypted protection key. A processor decrypts the encrypted data key using the protection key to obtain a data key.

Abstract: Method, systems, and computer program products for access configuration in hybrid network environments are disclosed. According to the method, an access configuration request is received from a client device in a first network environment, wherein the access configuration request is associated with an access to a network resource in a second network environment and comprises first authentication information associated with the client device. Further, second authentication information associated with the network resource is obtained. The first and second authentication information is further used to determine whether the access configuration request is verified. If the access configuration request is verified, connectivity between the client device and the network resource can be automatically established.

Abstract: Embodiments relate to progressively validating access token. In response to intercepting an initial call for a transaction for a service from a client, a token is validated for the initial call of the transaction for the service, the validating including contacting an authentication sever and locally storing a time to live received for the token. In response to intercepting at least one successive call for the transaction for the service from the client, it is determined that the token for the at least one successive call is valid based on the time to live locally saved. The at least one successive call for the transaction for the service is permitted to pass without contacting the authentication sever.

Abstract: Constructing a feature segment-based ensemble can include generating a data structure for each element of an initial set of training data. Multiple strongly correlated features of the elements can be identified as well as weakly correlated features. For each strongly correlated feature, a feature segmentation training set can be generated, each training set's elements each containing one of the strongly correlated features and excluding other strongly correlated features. One or more machine learning algorithms can be selected from a software library. The one or more machine learning algorithms can be applied to the feature segmentation training sets to train multiple machine learning models. Each machine learning model that improves the predictive accuracy of the feature segment-based ensemble can be integrated in the feature segment-based ensemble.

Abstract: A computer-implemented method according to one embodiment includes updating code segments of source code to include predetermined code pieces. The updated code segments are configured to output information about associated test cases upon the test cases being run. The method further includes running the test cases, and subsequent to a change being made to the source code, determining a prioritized subset of the test cases. The prioritized subset of the test cases is run. A computer program product according to another embodiment includes a computer readable storage medium having program instructions embodied therewith. The program instructions are readable and/or executable by a computer to cause the computer to perform the foregoing method.

Abstract: A method of analyzing source code includes receiving, by a processor, an updated version of a computer program, the updated version including a source code. The method also includes preprocessing, by a compiler, the source code for a target computing platform. Preprocessing the source code by the compiler includes identifying a macro condition associated with one or more computer instructions enclosed by a macro, determining object code corresponding to the one or more computer instructions based on a current value of the macro condition, and generating object code and macro information for output to a debugger, the macro information including one or more breakpoint conditions in the macro.

Abstract: A method, system, and computer program product for improving debugging efficiency through fallibility skip functionality are provided. The method initiates a fallibility skip mode within a programming environment. The method identifies a code module to be translated from a first coding language to a second coding language. The code module including a function statement. A modified function statement is generated based on the function statement and the initiation of the fallibility skip mode. One or more exception handling functions are added based on the modified function statement and the fallibility skip mode. The method generates a modified code module in the second coding language based on the fallibility skip mode.

Abstract: Examples described herein provide a computer-implemented method for identifying regression test failures that includes comparing a base code to a new code to locate an updated aspect of a program. The method further includes inserting debug code into corresponding source files for each of the base code and the new code for the updated aspect. The method further includes building a first image for the base code and a second image for the new code, the first and second images running in respective first and second containers. The method further includes comparing debugging outputs from a regression test of the respective first and second containers to identify a regression test failure. The method further includes implementing a corrective action to correct the regression test failure.

Abstract: Methods, computer program products, and/or systems are provided that perform the following operations: determining that a log multi-process debug mode is specified; obtaining a log file for debugging a source code, wherein the log file includes a plurality of log records; inserting a plurality of process identifier fields into each current log record in the log file; inserting a new log record into the log file for a created new process; and providing for performance of debugging for the source code based in part on the plurality of process identifier fields inserted into each current log record.

Abstract: Disclosed is an automatic parsing and path analysis method for a unit test code structure. The method comprises: acquiring compiled byte codes according to a language of a test program; traversing the complied byte codes, making instrumentation codes respectively in front of important statements, and acquiring node information and a small-segment path set (SSPS); analyzing the SSPS, replacing a part therein comprising nesting to obtain a SSPS excluding nesting as a basis, initializing a path table among the nodes, updating the path table by utilizing a depth-first algorithm, and obtaining path sets according to the path table; if all the path sets have been updated, returning to continuously update the path table; and outputting the acquired path sets and a program flowchart CFG obtained by analysis. The method above is capable of acquiring the path sets efficiently, thereby improving the capability of processing path analysis in actual software unit test.

Abstract: A computer-implemented method includes receiving, by a processor, an updated version of a computer program that includes several source code changes. A compiler preprocesses the source code changes for a target computing platform. The preprocessing includes identifying a compile time condition associated with one or more computer instructions enclosed by a macro, determining a current value of the compile time condition at the time of compiling, and determining corresponding object code based on the current value. Further, a macro information record for the macro is generated that includes the compile time condition, the current value, and an identification of the computer instructions. Further, a linker preprocesses the source code changes. This preprocessing includes determining that the object code is not included in an executable file, and updating the macro information record to indicate that the macro is not included in the executable file.