Abstract: Determination and provision of improved representations of program flow control are provided by a method that monitors execution of binary code of a program on a computer system. The monitoring includes monitoring manipulation(s) of call stack(s) maintained by the computer system for the execution of the binary code. The method, based on the monitoring, determines function call pattern(s) and branch pattern(s) exhibited by the execution of the binary code. The method identifies, from the binary code and using the determined function call pattern(s) and branch pattern(s), function calls and branches, relations between the function calls and branches, and function and variable names. The method also provides a representation of program flow control of the program using the identified function calls and branches, relations, and function and variable names.

Abstract: System and method for creating unit tests include: constructing a CFG representation for a computer program; utilizing the CFG to identify different potential execution paths and to identify different formulas corresponding to the different potential execution paths; parsing the source code to generate an abstract syntax tree; analyzing the computer program to determine whether it provides capability to set each of the associated variables in each formula by utilizing the abstract syntax tree; translating variables, fields, and expressions of the source code represented in each formula into decision variables; computing a solution to the list of pre-conditions from each formula to one of the potential solutions that specifies values for decision variables; selecting a formula, from the plurality of formulas, with a fewest number of associated variables; and creating a unit test, based on the data and the list of pre-conditions collected and solved.

Abstract: A computer system is configured to profile a program during an execution of the program. Profiling the program includes obtaining, by a first profiler, a first set of information associated with the execution of the program, and obtaining a second set of information associated with one or more executions of the function. The second set of information includes at least a call count or an execution time of each of the one or more executions of the function. The computer system then identifies a subset of the first set of information that is associated with the one or more executions of the function, and creates aggregate information based on the subset of the first set of information and the second set of information. The aggregated information is then reported.

Abstract: Techniques to facilitate provision of different user experiences to different groups of users of a mobile application are disclosed herein. In at least one implementation, a manifest provided by an application development and optimization platform is received that defines a plurality of user segments and a plurality of feature variants individually associated with the plurality of user segments. The manifest is processed to determine a segment of the plurality of user segments associated with a user of the mobile application along with a feature variant of the plurality of feature variants associated with the segment of the user. Execution of the mobile application is monitored for an occurrence of an event that triggers a default feature of the mobile application, and responsive to the event, the default feature is replaced with the feature variant associated with the segment of the user.

Abstract: Using real-time monitoring to inform static analysis, including: inspecting, using one or more static code analysis techniques, one or more components of a cloud deployment; detecting, using data gathered during the execution of the component in the cloud deployment, a condition; and modifying, based on the detected condition, the one or more static code analysis techniques.

Abstract: A method for loop escape analysis includes receiving a set of executable computer instructions stored on a storage medium, and determining a number of inputs to a loop associated with a data structure, storage space that would be saved by compressing the data structure, and a size of new elements required to compress the data structure. Upon reaching an end of the loop, the method determines whether to compress the data structure based on a comparison between the size of the new elements and the saved storage space. In response to determining to compress the data structure, the method compresses the data structure.

Abstract: An output rule specified via a distributed system execution request data structure for a requested calculation is determined, and a current rule is initialized to the output rule. A rule lookup table data structure is queried to determine a set of matching rules, corresponding to the current rule. The best matching rule is selected. A logical dependency graph (LDG) data structure is generated by adding LDG nodes and LDG edges corresponding to the best matching rule, precedent rules of the best matching rule, and precedent rules of each precedent rule. An execution complexity gauge value and a set of distributed worker processes are determined. The LDG data structure is divided into a set of subgraphs. Each worker process is initialized with the subgraph assigned to it. Execution of the requested calculation is coordinated and a computation result of the LDG node corresponding to the output rule is obtained.

Abstract: An intelligent scheduling method for supporting process task quantity splitting, which may relax the limit on the number of parallel machines for overdue task lists under the constraint of using as few parallel machines as possible, and split time-consuming process task quantities according to the operating status of machines in different periods.

Abstract: Methods, apparatus, systems, and articles of manufacture are disclosed to detect code defects. An example apparatus includes repository interface circuitry to retrieve code repositories corresponding to a programming language of interest, tree generating circuitry to generate parse trees corresponding to code blocks contained in the code repositories, directed acyclic graph (DAG) circuitry to generate DAGs corresponding to respective ones of the parse trees, the DAGs including control flow information and data flow information, abstraction generating circuitry to abstract the DAGs, invariant identification circuitry to extract invariants from the abstracted DAGs, and DAG comparison circuitry to cluster respective ones of the extracted invariants to identify respective ones of the abstracted DAGs with common invariants.

Abstract: A novel compiler is described. The compiler is able to view source code of the application in its entirety and can do so from the inside. Unlike other tools which examine the forensic data from an application crash after the fact, from the outside, the compiler of the present invention can provide novel data on function call stacks and function profiles during runtime. The application may be stopped immediately during runtime to prevent further or potential damage, but the forensic data that is collected is focused and can be used to show where vulnerabilities exists in the application and how they were exploited. Hashes are taken of function call stacks and used as unique identifiers or thumbprints which can be used to reduce the volume of forensic data that needs to be analyzed after an attack.

Abstract: This disclosure describes techniques implemented partly by a service provider network for containerizing applications. In an example, the techniques may include receiving annotated source code of an application to be containerized, analyzing one or more application component annotations included in the annotated source code to determine an application component that is to be included in a container associated with a containerized version of the application, and analyzing one or more method annotations included in the annotated source code to determine one or more methods of the application component to be included in an application programming interface (API) for the container. The container including the application component may then be built and the API for the container may be generated based at least in part on the one or more methods of the application component.

Abstract: A system for identifying root cause of anomalies in execution of an application comprising a plurality of operations is provided. The system comprising a preprocessing module configured to receive tracing data comprising a plurality of tracing spans each documenting, for a corresponding operation of the application, a plurality of properties and corresponding values, a signal splitting module configured to group the plurality of tracing spans in a plurality of groups such that each of the plurality of groups comprises operations with identical properties and corresponding values, an anomaly detection module configured to determine anomalous operations for each of the plurality of tracing data spans, a scoring module configured to calculate a plurality of anomaly scores each indicating a level of anomaly within each of the plurality of groups and a root cause identification module configured to analyze the anomaly scores and identify root cause of the detected anomalies according to the analysis.

Abstract: Systems and methods are provided for loop escape analysis in executing computer instructions. In one embodiment, a method comprises instructions performed by at least one computer process. The method comprises receiving a set of executable computer instructions stored on a storage medium (e.g., by reading the instructions from a tangible, non-transitory storage medium). The method further comprises analyzing the computer instructions to determine a loop, analyzing the computer instructions to determine at least one new variable in the loop, and storing, in a data structure, at least one of an operation related to the variable or a value related to the variable. The method further comprises determining whether to compress the data structure upon reaching the end of the loop, and, based on the determination, compressing the data structure. Systems and computer-readable media are also provided.

Abstract: The present disclosure describes a talent-identification system that can be used by companies to assist in the recruitment process for new employees. Additionally, the system can be used by job seekers to determine ideal career fields and industries. The system employs an array of neuroscience-based tests to assess a user's career propensities, after which the system can provide career recommendations to the user or report on employment suitability of the user to a company.

Abstract: A system for providing an API-driven continuous test platform is disclosed. The system may include one or more processors, a test engine, one or more test agents, and a database. The system may prepare (according to a configuration file) a first test configuration comprising a first selection of the one or more test agents, execute (using the test engine) the first test configuration to produce one or more first test results, and store (using the database) the one or more first test results. Finally, the system may process (using a continuous integration and continuous delivery (CI/CD) pipeline) the first test results by performing at least one of the following CI/CD processes: updating a central code base of an enterprise production environment, rejecting at least one code snippet processed by the test engine during execution of the first test configuration, and marking the first test results as inconclusive.

Abstract: Embodiments of the invention are directed to systems, methods, and computer program products for integration of multiple technical architecture diagrams into a single diagram. Architectural diagrams are commonly used in program level impact analysis and may depict relationships, constraints, and boundaries between components of an individual software program as well as the relationships between multiple software programs, hardware components, and users. The present invention automatically identifies touchpoints, or connections between multiple architecture diagrams and applies a series of image-processing algorithms, generating a single integrated diagram for organizational use. Embodiments of the invention also provide for multiple rounds of image processing, allowing multiple integrated diagrams to be combined into single diagrams.

Abstract: Techniques to facilitate provision of different user experiences to different groups of users of a mobile application are disclosed herein. In at least one implementation, a manifest provided by an application development and optimization platform is received that defines a plurality of user segments and a plurality of feature variants individually associated with the plurality of user segments. The manifest is processed to determine a segment of the plurality of user segments associated with a user of the mobile application along with a feature variant of the plurality of feature variants associated with the segment of the user. Execution of the mobile application is monitored for an occurrence of an event that triggers a default feature of the mobile application, and responsive to the event, the default feature is replaced with the feature variant associated with the segment of the user.

Abstract: Reuse of a thread-local return data structure to prevent a return data structure from being allocated every time asynchronous functions return. The system returns thread operation from the asynchronous function back to the caller function in a manner that the return data structure can be reused for future asynchronous function returns within that same thread. To do so, the system first accesses data that was generated by the asynchronous function in response to the caller function placing the function call to the asynchronous function. To determine if reuse is appropriate, the system determines that the caller function will use the return data structure as populated only once. If so, the system populates the reusable thread-local return data structure and returns that data structure to the caller.

Abstract: A method may include generating a callgraph by performing a static analysis of code that includes event handlers, and selecting, using the callgraph, a state of the code, selecting, using the callgraph, an event enabled in the selected state. The event corresponds to an event handler. The method may further include obtaining an input, obtaining a next state by executing the event handler with the obtained input in the selected state, in response to executing the event handler, generating an input modification rule using the obtained input, and generating, using the input modification rule and the obtained input, a modified input that bypasses a guard in the code that controls access to the point of interest.

Abstract: A collaborative software development environment includes a centralized repository security service that monitors a repository database of the collaborative software development environment for change notifications or events. When a change is noticed (e.g., pull request), the source repository is cloned and suitable images are spun up by an orchestrator, each of which is configured to perform a static analysis operation against the source code of the cloned repository. Results of each static analysis operation are stored in a database that can be accessed by client devices.

Abstract: Example implementations relate to determining potential test actions. Some implementations may include a data capture engine to capture data points during test executions of the application under test. The data points may include, for example, test action data and application action data. Additionally, some implementations may include a data correlation engine to correlate each of the data points with a particular test execution of the test executions, and each of the data points may be correlated based on a sequence of events that occurred during the particular test execution. Furthermore, some implementations may also include a test verification engine to determine, based on the correlation of the data points, a potential test action to perform during a future test execution of the application under test.

Abstract: Systems and methods for performing a consistency check test on a refactored method are disclosed. The method includes: at a computer, at execution time, receiving a refactored result generated by executing a refactored method and an old result generated by executing a corresponding original method associated with the refactored method; defining the refactored result generated by executing the refactored method as a first object and defining the old result generated by executing the original method as a second object; comparing the first object with the second object to identify any differences between the refactored result and the old result; and upon identifying one or more differences between the first object and the second object logging the differences in a log file.

Abstract: A platform includes a time series database. The platform also includes one or more instance data tables. A function library of the platform includes a set of function definitions and a scripting engine of the platform executes scripts. An advanced insight endpoint of the platform is communicatively coupled to and accessible by an advanced insights explorer user interface. The advanced insight endpoint receives one or more expressions from an expression component of the advanced insights explorer user interface, parses the one or more expressions and validates the one or more expressions against the set of function definitions. The endpoint generates and provides one or more scripts corresponding to the one or more expressions and receives results of execution the one or more scripts. Results are provided to a visualization component of the advanced insight user interface, to cause rendering of the results within the advanced insights explorer user interface.

Abstract: In one implementation, a method for providing security on controllers includes detecting computer-readable code running on a controller, the computer-readable code including code portions that each include instructions to be performed by the controller; identifying a current code portion of the computer-readable code; accessing an in-memory graph that models an operational flow of the computer-readable code, wherein the in-memory graph includes a plurality of nodes, each of the nodes corresponding to one of the code portions and each of the nodes having a risk value for the associated code portion that is a measure of security risk for the associated code portion; identifying the risk value for the current code portion; selecting, from a plurality of available flow control integrity (IMV) schemes, an IMV scheme based on the identified risk value; and applying, to the code portion as the code portion is running on the controller, the selected IMV scheme.

Abstract: Disclosed herein is a system for facilitating Change Impact Analysis (CIA) using modular program dependency graphs. Further, the system may include a communication device configured for receiving a source code for a software application and one or more changed lines corresponding to the source code from a user device, and transmitting one or more impacted lines from the source code associated with the software application to the user device. Further, the system may include a processing device configured for analyzing the source code to determine one or more modules, generating one or more modular Program Dependency Graphs (mPDGs) based on the analysis, updating at least one mPDG based on the one or more changed lines to obtain the at least one updated mPDG, searching the mPDG based on search expressions associated with the one or more changed lines, and calculating one or more impacted lines based on the searching.

Abstract: Techniques are described herein that are capable of performing automatic risk analysis of software. An automatic risk analyzer may determine correlations between binaries of the software and source files of the software, between the source files and functions (i.e., sub-routines) of the software, between changes to source code of the software and defects, new features, and/or feature enhancements in the software, between attributes of the software (e.g., attributes associated with the changes to the source code), etc. at various time instances. The automatic risk analyzer may compare the correlations corresponding to a first time instance and the correlations corresponding to a second time instance to determine any of a variety of temporal relationships regarding underlying factors, including but not limited to new feature(s), feature enhancement(s), defect(s), churn rate, code coverage, code complexity, etc.

Abstract: A system and method for automatically identifying and reporting test units of computer-executable code corresponding to computer-executable code changes within an integrated development environment application so that the code affected by the code changes are tested by the determined test units. The determining of the test units corresponding to the code changes may include determining both direct affectations and indirect affectations to avoid unnecessary testing and an incomplete identification of unit tests.

Abstract: Techniques for tracking microservices and facilitating rollbacks in response to exceptions are described herein. In an embodiment, a server computer system receives, from one or more sets of microservices program instructions, digital data identifying a plurality of tasks and a sequence of the tasks, the digital data specifying a particular computational workflow for execution by a computer. During execution of the workflow by the server computer system, the system identifies a particular failure in a first task of the plurality of tasks. The system causes displaying on a client computing device, a graphical user interface comprising a plurality of nodes, the nodes corresponding to the tasks. Within the graphical user interface, the system further causes displaying, with a particular node of the plurality of nodes corresponding to the first task, a graphical indication that the first task failed.

Abstract: In one embodiment, a sequence of microservice steps may be performed according to a programmed microservice workflow, while determining which executed tasks within the performed sequence of microservice steps have an individually corresponding rollback defined within the particular task. As such, a rollback path is stored corresponding to reversing the sequence of those executed tasks having an individually corresponding rollback, and, for each executed task having an individually corresponding rollback, a current status of the microservice workflow is also stored as a respective rollback status within the rollback path.

Abstract: A method for performing a static analysis may include extracting, from a caller function in code, a context-free inter-procedural rule including a callsite and a return value of a callee function. The callsite may invoke the callee function. The method may further include extracting, from the caller function, a context-sensitive parameter mapping rule that maps an input parameter of the callee function to an invocation value provided by the caller function at the callsite, deriving a derived value for the callsite using the context-free inter-procedural rule and the context-sensitive parameter mapping rule, and identifying a defect in the code by performing the static analysis using the derived value for the callsite.

Abstract: A product development management system presents the product specification traceability of the work items of the product requirement specification defining, the product function item planning, the product software and hardware architecture designing during the life cycle of the product development, such that the user and manager can handle the development work completeness, work item allocation and dispersion index and fineness index to which the specification item of each level extends. Through the product development management system of the present disclosure, the work team can understand the relation of their responsible engineering works, and establish confirmation and data change notification mechanism, so as to achieve a cooperation result.

Abstract: Privacy violation detection of a mobile application program is disclosed. Regular histories of the mobile application are mined. A call-graph representation of the mobile application program can be created and sequences of events of interest according to the platform specification of the mobile application can be collected. A plurality of learnable features are extracted from the regular histories. The plurality of learnable features are combined into a single feature vector which is fed into a machine-learning-based classification algorithm. Whether the mobile application program includes one or more permissions for accessing unauthorized privacy data of a mobile application user is determined based on a machine learning classification of the single feature vector. The collected sequences can be reduced into a plurality of feature vectors which can include at least one of a happens-before feature and a multiplicity of occurrences feature.

Abstract: Optimizing program execution includes performing, to obtain an expanded call graph, an expansion of an initial call graph. The expanded call graph includes nodes. The initial call graph is defined for a program that includes a root method and a child method. The method may further include calculating a cost value and a benefit value for inlining the child method, calculating an inlining priority value as a function of the cost value and the benefit value, and inlining, based on analyzing the expanded call graph and comparing the inlining priority value to a dynamic threshold, the child method into the root method. The child method may correspond to a node in the expanded call graph.

Abstract: Methods, systems, apparatuses, and computer program products are described herein that enable files, such as source code files used in building executable code, to be synchronized between two computing devices in a manner that utilizes file anchors or other time-stamped objects generated by and stored on each computing device. The file anchors can be used to determine which source code files on each computing device have been updated since a prior synchronization with another computing device and also to determine which version of a source code file stored on each computing device is the newer version, even when both computing devices have a different notion of time.

Abstract: The disclosed method may include (1) identifying a software update that includes at least one software function that has changed since a previous software update, (2) determining, based at least in part on the software update, one or more call paths that include (A) the software function that has changed since the previous software update and (B) at least one additional software function, (3) mapping the changed software function to one or more test scripts, (4) mapping the additional software function to one or more additional test scripts, (5) identifying at least one test script that is commonly mapped to both the changed software function and the additional software function, and then (6) performing a regression test by executing the test script that is mapped to both the changed software function and the additional software function. Various other systems, methods, and computer-readable media are also disclosed.

Abstract: A method, an apparatus, and a computer program product for optimizing variable size arguments in a programming language are provided. The method includes finding, in a target program, a call site having a variable-length argument. The method also includes generating a converted code for a callee of the call site, the generating including converting the variable-length argument to a plurality of arguments. The method further includes translating the call site to a call code for calling the converted code with the plurality of arguments instead of the variable-length argument.

Abstract: A processing device includes an instruction memory to store executable applications that are executable by a target processor, and a compiler. The compiler includes a builder module and a call graph generator. The builder module to build executable applications for the target processor based on a set of instructions. The call graph generator to create a first call graph that indicates a stack usage for each call path of the executable applications. If a first executable application built by the builder module includes a call path that exceeds a stack size constraint of the target processor, the builder module to optimize only functions within the call path that exceeds the stack size constraint in response to the request from the evaluation monitor, and to build a second executable application based on the set of instructions. The second executable application is optimized for stack memory usage of the target processor.

Abstract: A connection can be made to a processing element of a remotely deployed and live streaming application executed by a first data processing system, the processing element containing at least one operator that processes at least one tuple. As the live streaming application is executed, without slowing or modifying data flow of the live streaming application execution to client devices, a copy of the tuple and a memory dump of state data for a state of the operator can be received, and the tuple can be tracked through a call graph. The state data can be loaded into a local instance of the operator loaded into a debugger. At least a portion of the call graph can be presented to a user, and a flow of the tuple through the call graph based on the state data for the operator can be indicated.

Abstract: A method is provided for operating a trace procedure, which traces execution of a computer program, where the program uses different callable modules. A program stack is used to store trace buffer information and an error state, and the modules include calls of the trace procedure. The method includes: (i) when entering execution of a module, storing the current write position of the trace buffer and a cleared error flag in the current frame of the stack; (ii) in case of an error condition during execution of the program, setting the error flag in the current frame; and (iii) when leaving execution of a module, determining if the error flag is set, and if not, then rewinding the trace buffer to the write position stored in the current frame, and deleting the current write position of the trace buffer and the error flag from the stack.

Abstract: Computer program, methods, and systems for code modification of a programming language platform and a software application in an intermediate language at different times are disclosed. The methods and system may modify a portion of the programming language platform in the intermediate language at a first time to alter a functionality of or add a new functionality to the programming language platform; and may modify the software application in the intermediate language at a second time different from the first time, where the software application may be modified based on a runtime analysis rule that uses the altered or added new functionality of the programming language platform. The modified programming language platform may be included in a first package, and the modified software application may be included in a second package, and executed on the modified programming language platform.

Abstract: Techniques for identifying a stack frame responsible for resource usage are described. For instance, techniques described herein enable a particular process and a particular stack frame and/or set of stack frames of the process that are high resource consumers to be identified. According to various implementations, resource usage of a process is observed and recorded over a period of time. A data structure is generated that characterizes the resource usage of the process over the sampling period. The data structure be evaluated to identify a stack frame that is responsible for excess resource consumption. In at least some implementations, a remedial procedure can be performed to attempt to reduce the process's resource usage.

Abstract: Converting a hybrid flow can include combining each of a plurality of task nodes with a plurality of corresponding operators of the hybrid flow and converting the combined plurality of task nodes and the plurality of corresponding operators of the hybrid flow to a data flow graph using a code template.

Abstract: An example method of detecting incompatibility between an application and an application dependency includes identifying a first set of contracts exposed in a first version of an application dependency. Each contract includes a symbol and a corresponding signature. The example method also includes comparing the first set of contracts to a corresponding second set of contracts exposed in a second version of the application dependency. The example method further includes determining, based on the comparing, whether the first set of contracts matches the second set of contracts. If the first set of contracts matches the second set of contracts, an indication that the second set of contracts is compatible with the application is provided. If the first set of contracts does not match the second set of contracts, an indication that the second set of contracts is not compatible with the application is provided.

Abstract: A method for expanding inline function calls in inlining scenarios includes receiving an ordered list of inlining options for a computer program and a relational data structure representing dependencies between the inlining options, wherein each inlining option includes an associated cost value and an associated benefit value. A maximum-benefit inlining plan for a selected inlining option of the ordered list is then determined, wherein the maximum-benefit inlining plan includes a set of inlining options from the ordered list that provide a maximum combined benefit value for a combined cost value that is equal to or less than a maximum cost budget, subject to the following conditions: each inlining option of the set precedes, or is, the selected inlining option in the ordered list, and for each inlining option of the set, the set also includes each inlining option that the respective inlining option is dependent on.

Abstract: A method, an apparatus, and a computer program product which capture and use analytics data relating to the internal activity of software programs executing in a message-passing runtime environment, such as that provided by Objective-C. The invention exploits the well documented interfaces of these environments together with their dynamic runtime capabilities to insert data collection and analysis code into an application without modification of the target application.

Abstract: An apparatus can include a first state machine engine configured to receive a first portion of a data stream from a processor and a second state machine engine configured to receive a second portion of the data stream from the processor. The apparatus includes a buffer interface configured to enable data transfer between the first and second state machine engines. The buffer interface includes an interface data bus coupled to the first and second state machine engines. The buffer interface is configured to provide data between the first and second state machine engines.

Abstract: In an approach for determining compatibility between a computing device and a software application, a processor receives code of a software application. A processor generates a call graph for the software application using the code, wherein the call graph describes at least a first type of hardware component required to execute the software application. A processor identifies a set of one or more hardware components included within a computing device. A processor determines whether the computing device is compatible with the software application based on, at least, the call graph and the determined set of one or more hardware components included within the computing device.

Abstract: In one embodiment, a processor includes a performance monitor including a last branch record (LBR) stack to store a call stack to an event of interest, where the call stack is collected responsive to a trigger for the event. The processor further includes logic to control the LBR stack to operate in a call stack mode such that an entry to a call instruction for a leaf function is cleared on return from the leaf function. Other embodiments are described and claimed.

Abstract: In an aspect of managing resource exhaustion, a method includes receiving a program code that is configured for generating a random number. The generating is identified as vulnerable to a resource exhaustion. The method also includes identifying a statement in the program code at which a value of a variable associated with the generating of the random number is affected, inserting a hooking code in the statement for monitoring the variable at the statement, and running the program code in a plurality of iterations. A consumption level of the resource is varied in the plurality of iterations. The method further includes monitoring a plurality of values of the variable in the plurality of iterations. The method also includes executing a regression analysis on the plurality of values and returning a root cause of the vulnerability.

Abstract: A method for expanding inline function calls in inlining scenarios includes receiving an ordered list of inlining options for a computer program and a relational data structure representing dependencies between the inlining options, wherein each inlining option includes an associated cost value and an associated benefit value. A maximum-benefit inlining plan for a selected inlining option of the ordered list is then determined, wherein the maximum-benefit inlining plan includes a set of inlining options from the ordered list that provide a maximum combined benefit value for a combined cost value that is equal to or less than a maximum cost budget, subject to the following conditions: each inlining option of the set precedes, or is, the selected inlining option in the ordered list, and for each inlining option of the set, the set also includes each inlining option that the respective inlining option is dependent on.