International Business Machines Corporation

Other

Jim Alain Laredo

Maja Vukovic

John Erik Wittern

Yunhui Zheng

Aleksander A Slominski

Sriram K Rajagopal

Anca Sailer

Thomas E Chefalas

Frank Andre Schaffa

Alla Segal

Rahul P Akolkar

Chang-Shing Perng

Christopher Charles Young

Ignacio Silva-Lepe

Tao Tao

Alessandro Morari

Biplav Srivastava

Yaoping Ruan

Milton H Hernandez

Vinod Muthusamy

Arjun Natarajan

Yexi Jiang

Yang Zhou

Annie T Ying

Annie Tsui Tsui Ying

Zhong Su

Bo Yang

Gennaro A Cuomo

Hui Lei

Shiwan Zhao

Julian Timothy Dolby

Liangzhao Zeng

Hani Talal Jamjoom

Nicholas C M Fuller

Mattias Marder

Honglei Guo

Ying Huang

Shriram Rajagopalan

Daniel J Williams

Sahil Suneja

Nandagopal Seshagiri

Brian L White

Saurabh Pujar

Luca Buratti

Yufan Zhuang

John E Q Wittern

Valentina Salapura

Marco Pistoia

Yu Deng

Roman Vaculin

Sheng Hua Bao

Sougata Mukherjea

Alfio Massimiliano Gliozzo

Zon-Yin Shae

Heiko Hary Ludwig

Vugranam Chakravarthy Sreedhar

Gopal Sarma Pingali

Rong Nickle Chang

Alaa Salah Youssef

Mihaela Ancuta Bornea

Shu Tao

Thao Ngoc Nguyen

Kamal Bhattacharya

Qi Hu

Apurva Kumar

Gaetano Rossiello

Thomas Yu-Kiu Kwok

Laura Zaihua Luan

Jeaha Yang

Jeffrey Scott McCarley

Kunwadee Sripanidkulchai

Karunakar Bojjireddy

Carroll Eugene Fulkerson, Jr

Kuo Zhang

Markus Gero Stolze

Hong Lin Guo

Graeme Neville Dixon

Yew-Huey Liu

Annie T T Ying

Amber Roy Chowdhury

Hung-yang (Henry) Chang

Bruno Wasserman

Sridhar Maradugu

Supreet R Mandala

Piyawadee Sukaviriya

Gregory J Rosensteel

Maoyuan Qu

Liliana Pasquale

Ray Ming Yeh

Robert Calhoun

Alan Cha

Techniques regarding training one or more AI models for a source code understanding task are provided. For example, one or more embodiments described herein can comprise a system, which can comprise a memory that can store computer executable components. The system can also comprise a processor, operably coupled to the memory, and that can execute the computer executable components stored in the memory. The computer executable components can comprise a training component that can train an artificial intelligence model on source code samples for a source code understanding task. The source code samples can be ranked based on code complexity.

Complexity based artificial intelligence model training

Techniques regarding augmenting one or more training datasets for training one or more AI models are provided. For example, one or more embodiments described herein can comprise a system, which can comprise a memory that can store computer executable components. The system can also comprise a processor, operably coupled to the memory, and that can execute the computer executable components stored in the memory. The computer executable components can comprise training augmentation component that can generate an augmented training dataset for training an artificial intelligence model by extracting a simplified source code sample from a source code sample comprised within a training dataset.

Training data augmentation via program simplification

In a computer-implemented method for improving a static analyzer output, a processor receives a labeled data set with labeled true vulnerabilities and labeled false vulnerabilities. A processor receives pretrained contextual embeddings from a contextual embeddings model. A processor maps the true vulnerabilities and the false vulnerabilities to the pretrained contextual embeddings model. A processor generates a fine-tuned model with classifications for true vulnerabilities.

Contextual embeddings for improving static analyzer output

Approaches presented herein enable fault detection. More specifically, implementation code of one or more functions is identified from source code. The implementation code of the one or more functions is converted to corresponding Abstract Syntax Trees (ASTs). The implementation code of the one or more functions is represented as a first plurality of sets of AST paths over the ASTs. Classification results for the one or more functions are generated with a classifier based on the first plurality of sets of AST paths for the implementation code of the one or more functions. Each of the classification results indicates a probability of having at least one fault in a corresponding function of the one or more functions. Fault detection results of the source code are generated based on the classification results.

Source code fault detection

A debugging tool and method for statically verifying programs that invoke web-based services through API calls is provided. The tool receives source code that comprises one or more invocation of web APIs for requesting web-based services. The tool also receives a set of web API specifications. The tool extracts a set of request information for each web API invocation in the source code, the set of request information including a usage string of an URL endpoint. The tool verifies whether the set of request information complies with the received web API specifications and reports a result of the verification.

Analysis to check web API code usage and specification

One or more systems, computer-implemented methods, and computer program products to facilitate a process for consensus regarding proceeding with a request of a transaction are provided. A system can comprise a memory that stores computer executable components and a processor that executes the computer executable components stored in the memory. The computer executable components can comprise a services component that operates a service of a transaction, where the services component approaches consensus regarding a request of the transaction by communicating with one or more other services components that operate one or more other services immediately upstream or downstream in the transaction to the service. The services component can approach the consensus by communicating only with the one or more other services components. To approach the consensus, the services component can communicate one or more messages that include one or more requests, votes or final decisions.

Request facilitation for approaching consensus for a service transaction

A method, a computer system, and a computer program product for building pre-trained contextual embeddings is provided. Embodiments of the present invention may include collecting programming code. Embodiments of the present invention may include loading and preparing the programming code using a specialized programming language keywords-based vocabulary. Embodiments of the present invention may include creating contextual embeddings for the programming code. Embodiments of the present invention may include storing the contextual embeddings.

Building pre-trained contextual embeddings for programming languages using specialized vocabulary

Using a natural language processing model, a historical defect report comprising a defect description in narrative text form is parsed. Within a code repository, source code associated with the historical defect report is identified. From the historical defect report and the source code, a logging rule comprising a defect type, logging placement information corresponding to the defect type, and logging format information corresponding to the defect type is generated. By parsing a new defect report using the natural language processing model, the new defect report reporting a defect in new source code, it is determined that the logging rule applies to the new defect report. Logging source code generating logging output when executed is placed within the new source code according to the logging rule. Execution of the new source code including the logging source code is caused, generating the logging output.

Automated defect type based logging integration within source code

Aspects of the invention include assessing, by a management layer executing on a first processor, a query from a client application requesting data from a server. The assessing occurs prior to the query being executed by a provider. The assessing includes extracting, by the management layer, characteristics of the query. The management layer compares the extracted query characteristics with a policy defined by the provider. Based at least in part on results of the comparing, it is determined by the management layer whether the query is permitted to be executed by the provider at the server. The management layer initiates execution of the query at the server in response to determining that the query is permitted to be executed. The management layer prevents execution of the query at the server in response to determining that the query is not permitted to be executed.

GraphQL management layer

Techniques regarding autonomously generating one or more graph query language schemas are provided. For example, one or more embodiments described herein can comprise a system, which can comprise a memory that can store computer executable components. The system can also comprise a processor, operably coupled to the memory, and that can execute the computer executable components stored in the memory. The computer executable components can comprise an interface component, operatively coupled to the processor, that can generate a schema for a graph query language wrapper that can translate a query to a request against a target application programming interface. The schema can comprise a sanitation map that can delineate a relation between a raw data format expected by the target application programming interface and a sanitized data format exposed by the graph query language wrapper.

Autonomous generation of a graph query language interface on top of an application programming interface

A method and system of matching an application program interface (API) code usage with an API specification are provided. A program having an API code usage is received and its features are extracted therefrom. Features from meta data of a plurality of API specifications are extracted. For each API specification of the plurality of API specifications, a match probability with the API code usage is determined. An API specification having a highest probability is determined. The API code usage is matched with the API specification having the highest probability.

Probabilistic matching of web application program interface code usage to specifications

A computer-implemented method and system for authenticating API is provided. An API invocation request associated with a user is received. An API operation and the shareable API key includes validating API key credentials of the shareable API key associated with the API invocation request. There is an additional validation of user credentials of the user associated with the API invocation request. It is determined whether the user having the validated user credentials is authorized to use the shareable API key to invoke the API operation. The API operation is executed in response to determining the user having validated user credentials is authorized to use the shareable API key to invoke the API operation. The authentication integrates validation of the user and the shareable API key, and determines whether a user is a subscriber of a multi-tenant subscription service.

Authenticating API service invocations

A computer implemented method for testing an application according to usage data includes receiving an application to be tested and a set of usage data corresponding to the application to be tested, wherein the set of usage data corresponds to previously executed code sequences, identifying one or more code sequences of interest corresponding to the received application, wherein the code sequences of interest correspond to codes sequences that are configured to exercise the received application, extracting concrete usages of the code sequence of interest from the received set of usage data, generating one or more test cases for the application according to the extracted usages, and providing the one or more generated test cases. The method may additionally include testing the application according to the one or more generated test cases.

Gray-box testing based on concrete usages

Techniques for autonomously generating a code usage summary associated with a web application programming interface request are provided. In one example, a computer-implemented method can comprise evaluating, by a system operatively coupled to a processor, data from a data repository, wherein the evaluating is based on a defined machine learning process. Also, the computer-implemented method can comprise generating, by the system, a usage summary of the data, wherein the usage summary is based on a statistic derived from a web application programming interface request, and the web application programming interface request is associated with the data.

Approach to summarize code usage

Growing community of inventors

Katonah, NY, United States of America

Jim Alain Laredo