Abstract: An automated system is presented for unit testing an application in a mainframe execution environment. A plurality of stub objects reside in the mainframe execution environment, such that each stub object in the plurality of stub objects represents a different stub type. A command translator table is configured with an entry for each command available for an online transaction processor. Each entry in the command translator table specifies a stub type for the command and includes a listing of possible arguments associated with the given command, such that each possible argument in the listing of possible arguments has a specified category type. A test configurator executes in the mainframe execution environment and is configured to receive and parse a test input file. A setup routine interacts with the test configurator to receive records from the test input file.

Abstract: Training and/or utilization of machine learning model(s) (e.g., neural network model(s)) in automatically generating test case(s) for source code. Techniques disclosed herein can be utilized in generating test case(s) for unit test testing (or other white-box testing) and/or for functional testing (or other black-box testing). In some implementations, the machine learning model(s) can be trained on source code, unit test pairs. In some additional or alternative implementations, reinforcement learning techniques can be utilized to check for correctness of base source code, target source code pairs (e.g., by matching program execution of different branches).

Abstract: A system comprising processing circuitry a memory storing instructions that cause the system to detect a code change to source code included in a code repository, identify a relationship between the code change and an associated product feature, determine one or more dependent product features impacted by the code change, select a set of test cases including a subset of test cases related to the associated product feature and a subset of test cases related to the one or more dependent product features, execute the set of test cases, and update the code-to-feature mapping using results of executing the set of test case.

Abstract: Embodiments of the present invention relate to a multi-thread exit method and a mobile terminal. The method is applicable to the mobile terminal. The method includes: obtaining an exit identifier and crash determination information of a thread; and destroying the thread according to the exit identifier and the crash determination information. In the method, an exit identifier and crash determination information of a thread are obtained, both the exit identifier and the crash determination information of the thread are determined, and different destruction modes are selected according to determination results to destroy the thread, thereby avoiding crash and congestion when a multi-thread exits and improving the stability of multi-thread exit.

Abstract: Embodiments described herein include, software, firmware, and hardware logic that provides techniques to perform arithmetic on sparse data via a systolic processing unit. Embodiment described herein provided techniques to skip computational operations for zero filled matrices and sub-matrices. Embodiments additionally provide techniques to maintain data compression through to a processing unit. Embodiments additionally provide an architecture for a sparse aware logic unit.

Abstract: A system and method for function summarization. In some embodiments, the method includes: identifying a basic function called by a first function, the first function having a signature; determining a first type, the first type being a type of an argument of the basic function or a type of a return value of the basic function; and propagating the first type, to determine a first portion of the signature of the first function.

Abstract: A method for testing a system under test (SUT) in an active environment includes receiving, by a testing system, a code path of the SUT that causes a soft failure in the active environment. The soft failure occurs in the active environment during execution of the SUT based at least on a parameter of the active environment. The method further includes generating, by the testing system, multiple tests for testing the SUT, the tests generated based on a coverage model of the SUT, wherein the coverage model uses several attributes. The method further includes selecting, by the testing system, from the generated tests, a set of tests that are associated with the code path. The method further includes executing, by the testing system, only the set of tests that are selected on the SUT to analyze a cause of the soft failure.

Abstract: A system and method for determining automated uptime of internet-based software may include one or more memories storing check suites, each check suite including an ordered sequence of a plurality of checks corresponding to an execution flow of an ordered sequence of functions of the internet-based software; and one or more processors configured to determine a total amount of down time for a monitoring period by: during each time interval of the monitoring period, performing each of the plurality of check suites on the internet-based software, and applying at least one weighing factor to results of performing each of the plurality of check suites.

Abstract: A seed depth device for an agricultural planter includes an electric motor. The seed depth device also includes an actuator driven by the electric motor and arranged to move to a home position. The seed depth device further includes a first stop proximate to the actuator when in the home position. The seed depth device yet further includes at least one controller including a computing processor and a computer readable storage medium configured to control the electric motor. The seed depth device also includes a seed depth auto-learn system at least in-part stored and executed by the at least one controller, the seed depth auto-learn system configured to learn the home position based at least in-part on the actuator stalling upon the first stop, wherein the seed depth auto-learn system is configured to move the actuator a prescribed distance away from the first stop to establish the home position.

Abstract: A system and method are provided for executing process workflows. The method includes obtaining via a communications module, a representation of a workflow as a graph, the graph including a plurality of interconnected workflow tasks. The method also includes storing the graph in a graph database, navigating through the workflow tasks in the graph as the process is executed, and publishing via the communications module, a workflow state change with a topic for the current workflow task. The method also includes receiving via the communications module, a document for the current workflow task, wherein a state of the process is implied by the topic position in the graph, and wherein the topic determines at least one microservice to be employed. The method also includes having at least one workflow task associated with the current workflow task executed by instructing a corresponding one or more microservices via the communications module.

Abstract: A directed graph for an application under test (AUT) hosted at a hosting computing device is generated based on test flows. Each test flow traverses GUI objects of the AUT via GUI events. Each GUI event is associated with a transition from a first GUI object of the AUT to a second GUI object of the AUT. The GUI event represents interaction with the GUI of the AUT at a client computing device and that resulted in the transition. The directed graph includes nodes that each correspond to a GUI object of the AUT and edges that each correspond to a GUI event.

Abstract: A system including a user interface, a memory, and a processor configured to perform operations stored in the memory is disclosed. The operations may include receiving an application specification including an application algorithm, and extracting from the application algorithm a first and a second node. The first node may include a first component of the application algorithm, and the second node may include a second component of the application algorithm that may be different from the first component. The operations may include analyzing execution dependency of the first node on the second node. The analyzing execution dependency may include analyzing computational requirements, bandwidth requirements, and input trigger requirements of the first node and the second node based on parallelism of available resources.

Abstract: A method of selecting a distributed framework includes identifying, by a selection device coupled to a memory, at least a first cryptographic evaluator of a plurality of cryptographic evaluators, wherein identifying the at least a first cryptographic evaluator further comprises and evaluating a secure proof generated by the at least a first cryptographic evaluator, and identifying the at least a first cryptographic evaluator as a function of the secure proof, assigning, by the selection device, a confidence level of the at least a first cryptographic evaluator, and selecting, by a selection device, a distributed framework from the plurality of cryptographic evaluators as a function of the confidence level, and assigning a task to the distributed framework.

Abstract: Apparatus, systems, articles of manufacture, and methods for a context and complexity-aware recommendation system for efficient software development.

Abstract: A method to process subroutine-structured graph-based intermediate representations during formal language processing implemented by a computing device. The method includes classifying a set of subroutines identified in an intermediate representation of code according to mutually recursive relationships between subroutines in the set of subroutines, recording the mutually recursive relationships, labeling to track the mutually recursive relationships, constructing a set of graph representations, collecting partial positions that distinguish points of action in generated code, labeling nodes of the graph of the intermediate representation, generating a subsequent intermediate representation by serialization of the graph of the intermediate representation through pre-order depth-first traversal, and creating the generated code from the intermediate representation.

Abstract: A method for identifying a type of a variable within a binary performed on a computing device is provided. The method comprises, identifying a variable from disassembly code of a binary, and determining a type of the variable based on an instruction of the disassembly code, associated with the variable.

Abstract: A method for profiling energy usage in graphics user interfaces (UI) in handheld mobile devices is disclosed, which includes quantifying the central processing unit (CPU) energy drain of each UI update, quantifying the graphics processing unit (GPU) energy drain of each UI update, quantifying the number of pixels changed due to each UI update, identifying an UI update that consumes energy drain but results in no pixel changes to the displayed frame as a graphics energy bug.

Abstract: Disclosed herein are techniques for identifying software interdependencies based on functional line-of-code behavior and relation models. Techniques include identifying a first portion of executable code associated with a first controller; accessing a functional line-of-code behavior and relation model representing functionality of the first portion of executable code and a second portion of executable code; determining, based on the functional line-of-code behavior and relation model, that the second portion of executable code is interdependent with the first portion of executable code; and generating, based on the determined interdependency, a report identifying the interdependent first portion of executable code and second portion of executable code.

Abstract: An analyzing unit analyzes source code specified by an input unit, to obtain fixed values which are used to distinguish between pieces of content of communication data for realizing a dependency relationship between pieces of software. A relationship between the obtained fixed values and software elements is saved in a storage unit. By an influence-by-change analyzing unit, pieces of information on a plurality of pieces of software saved in the storage unit are associated with each other based on the fixed values used to distinguish between pieces of content of communication data, and a dependency relationship between software program elements is analyzed. Analysis results are displayed in a diagram or table format on a display unit.

Abstract: Systems and methods for configuration management through information and code injection at compile time. An example method comprises: receiving a source code comprising one or more references to a variable; receiving metadata associated with the source code, wherein the metadata specifies a range of values of the variable; and identifying, in view of the range of values of the variable, a reachable section of the source code.

Abstract: Techniques are described herein that are capable of generating mock-based unit test(s) for an end-to-end test of a code snippet (a.k.a. system to test (STT)). For instance, method(s) in a code snippet that have a designated functionality are replaced with a wrapper function that has the designated functionality. Shims and/or stubs are inserted in the wrapper function to replace behavior of the method(s) with regard to callback method(s) from one or more dependencies of the method(s). Inputs that are included in the callback method(s) and that are intended for the code snippet are simulated to provide simulated inputs for the code snippet.

Abstract: Disclosed examples to insert buffers in dataflow graphs include: a backedge filter to remove a backedge between a first node and a second node of a dataflow graph, the first node representing a first operation of the dataflow graph, the second node representing a second operation of the dataflow graph; a latency calculator to determine a critical path latency of a critical path of the dataflow graph that includes the first node and the second node, the critical path having a longer latency to completion relative to a second path that terminates at the second node; a latency comparator to compare the critical path latency to a latency sum of a buffer latency and a second path latency, the second path latency corresponding to the second path; and a buffer allocator to insert one or more buffers in the second path based on the comparison performed by the latency comparator.

Abstract: A method adapts a dataflow instance. A set of source data nodes, a set of terminal data nodes, and a set of computation nodes in the dataflow are identified from a directed graph. The set of computation nodes performs operations on data flowing from the set of source data nodes through computation nodes and onwards to terminal data nodes in the dataflow. The data nodes are evaluated with policies and a user context. A number of transformation compute nodes is computed from the policy decisions and added downstream of the set of source data nodes and optionally upstream of the set of terminal data nodes when the data, the dataflow or system does not meet the declared policies without the necessary computed number of transformation compute nodes. The number of transformation compute nodes are an additional portion of the overall set of computation nodes to enforce the declared policy.

Abstract: Disclosed herein are techniques for identifying software interdependencies based on functional line-of-code behavior and relation models. Techniques include identifying a first portion of executable code associated with a first controller; accessing a functional line-of-code behavior and relation model representing functionality of the first portion of executable code and a second portion of executable code; determining, based on the functional line-of-code behavior and relation model, that the second portion of executable code is interdependent with the first portion of executable code; and generating, based on the determined interdependency, a report identifying the interdependent first portion of executable code and second portion of executable code.

Abstract: Embodiments of the invention are directed to systems, methods, and computer program products for a security vulnerability analysis and management platform utilizing deep learning technology and knowledge graph database structures. The system is configured to receive software code and metadata corresponding to existing issues and defects present in the software code or associated with the implementation of the software code. By applying a deep learning technique to extract data from the open source software code, wherein the data corresponds to potential issues and defects in the open source software code, the system is configured to populate a knowledge graph database and build a unified cybersecurity ontology that can later be organized and queried based on user input.

Abstract: An illustrative embodiment of a computer-implemented process for managing aliasing constraints, identifies an object to form an identified object, identifies a scope of the identified object to form an identified scope, and assigns a unique value to the identified object within the identified scope. The computer-implemented process further demarcates an entrance to the identified scope, demarcates an exit to the identified scope, optimizes the identified object using a property of the identified scope and associated aliasing information, tracks the identified object state to form tracked state information; and uses the tracked state information to update the identified object.

Abstract: Computer systems and methods for generating and interacting with a micro-service framework are provided. A micro-service corresponds to one or more deep link/API calls that carry out some particular function. A static analysis of an app is conducted, from one or more starting sources of the app to identify one or more valid and feasible execution paths, as well as corresponding input parameters within the app. Each valid execution path with corresponding input parameters represent a “deep link” or “API” for that app. The information regarding the deep link is collected and stored as a micro-service in a micro-service catalog. A micro-service framework is implemented that receives a micro-service request (i.e., a request that the micro-service be carried out on behalf of a computer user) from a UX client and executes that micro-service request via execution of the deep link.

Abstract: Reducing data skew when performing computational jobs (such as responding to complex queries or queries on big data sets). To gather performance information for a vertex in a distributed stage, the distributed stage is processed and the resulting performance information being generated. The system then identifies a performance outlier of the vertices, which varies from a performance norm of other vertices. A trigger instruction is then generated that is structured to trigger the performance outlier vertex to gather data distribution information of the data that the performance outlier vertex previously processed. The trigger instruction may thus be executed to cause the performance outlier vertex to gather the data distribution information for evaluation for data skew.

Abstract: Method, apparatus and product for symbolic execution of alternative branches. The method comprising reaching, during symbolic execution of a Control Flow Graph (CFG) of a program, a branching node in the CFG with a first symbolic state, wherein the branching has at least a first branch and a second branch, wherein the first and second branches end at a joining node in the CFG. The method further comprises symbolically executing the first branch using the first symbolic state so as to determine a second symbolic state. The method further comprises symbolically executing the second branch using the second symbolic state so as to determine a third symbolic state. Accordingly, the third symbolic state is based on sequential symbolic execution of alternative branches.

Abstract: A system for analysis and transaction processing includes an interface and a processor. The interface is configured to receive a task. The processor is configured to determine a processing estimate associated with the task by determining required resources for a set of possible processing solutions to perform the task and to determine a task engine based at least in part on the processing estimate. The task engine comprises an analysis engine or a transaction engine. The analysis engine or the transaction engine is used to process the task. The processor is further to provide the task to the task engine.

Abstract: An application testing developer system provides a platform for generating real-time suggestions for allocating test cases to testers in a distributed environment based on monitored characteristics from previous testing of a test application. The application testing developer system includes a smart advisory tool that optimizes test case allocation in real-time, adaptively assigns incentives in real-time to test cases for prioritizing testing of certain test cases over others, and monitors and validates testing activities.

Abstract: The invention relates to methods for determining a haplotype for an organism by using a system for transforming SNP alleles found in sequence fragments into vertices in a graph with edges connecting vertices for alleles that appear together in a sequence fragment. A community detection operation can be used to infer the haplotype from the graph. The system may produce a report that includes the haplotype of the SNPs found in the genome of that organism.

Abstract: A non-transitory computer-readable storage medium storing a control program that causes a computer to execute a process, the process including obtaining, for each of a plurality of job flows to which coincident input data is inputted, data excluded from the coincident input data of each of the plurality of job flows by a data extraction process or information specifying the excluded data, each of the plurality of job flows defining a plurality of processes including the data extraction process to be executed, and determining whether the plurality of job flows whose output data are coincident each other are aggregated or not based on the excluded data or the information specifying the excluded data.

Abstract: Disclosed aspects relate to stream operator management. A stream operator may be analyzed with respect to a set of usage indicators. The stream operator may operate on a computer processor and correspond to a processing element for processing a stream of tuples. Based on analyzing the stream operator, a set of profile data for the stream operator may be determined. The set of profile data for the stream operator may be established for utilization to develop a streaming application.

Abstract: A system and a method are creating a linked list scripts for a networking device. The system receives a set of nodes defining script functionality and generates a script by coupling the nodes in a nodal structure based on desired order of execution, wherein a leaf node is an standalone node with no child node, and wherein a nugget node includes one or more child nodes, each child node being a nugget or leaf node. The system then determines an execution path through a subset of nodes in the nodal tree structure based on one or more input values. The system also compiles the subset of nodes into a linked list of operations, which follows the execution path, and executes the path of operations within the compiled linked list of operations.

Abstract: In an embodiment, a processing resource allocation method is disclosed. The method may include identifying an instruction mapped to data having a preselected data location. The method may also include determining whether to transfer a call of the instruction from a first processing unit (PU) to a second PU based on the preselected data location.

Abstract: A method and system for renewing software at the component-level is provided. A client program includes a base component for loading a software component into at least one loadable region of the program to update the program. Code in the software component is for writing state data associating the state of the update in storage, upon execution of the software component, and testing the state data to verify condition of the updated program and disallowing rollback and roll-forward attacks, the state data comprising hash chain values. The state data for verifying the correctness of the updated program is entangled with application data used for the program functionality. A server includes: an update pool having a plurality of software updates deployed in each client, and a policy control for monitoring and controlling at least one of: the length of time the client runs until the software update is invoked, a chain of the updates; and the granularity of the update.

Abstract: Fusion hints can be generated in order to recommend streams application actors (like streams operators) for fusion or separation in a streams computing environment. Profiles can be made for the streams application actors, and fusion candidates can be determined from the profiles, based on fusion candidate rules. Based on the fusion candidate rule satisfied, a particular associated fusion recommendation can be identified and made to the user via a user interface. The recommendation can be displayed, along with the identities of the streams application actors identified as fusion candidates.

Abstract: Fusion hints can be generated in order to recommend streams application actors (like streams operators) for fusion or separation in a streams computing environment. Profiles can be made for the streams application actors, and fusion candidates can be determined from the profiles, based on fusion candidate rules. Based on the fusion candidate rule satisfied, a particular associated fusion recommendation can be identified and made to the user via a user interface. The recommendation can be displayed, along with the identities of the streams application actors identified as fusion candidates.

Abstract: The analysis of an intermediate representation of source or program code. An initial version of an initial representation of the source or program code is accessed and statically analyzed. For one or more portions of this initial version, the analysis component queries an analysis-time resolution component that provides supplemental intermediate representations corresponding to the portion. This supplemental intermediate representation provides further clarity regarding the portion, and is analyzed. If defects are found, they may be reported.

Abstract: A non-transitory computer-readable storage medium may include instructions stored thereon that. When executed by at least one processor, the instructions may be configured to cause a computing system to at least determine which links connecting old super blocks to old spine blocks via a plurality of Optical Circuit Switches (OCSs) in a network to disconnect to accommodate at least one new super block and at least one new spine block being added to a switching network, the determining including determining a maximum of m links per OCS to disconnect, connect the old super blocks to the at least one new spine block via the OCSs associated with the links to be disconnected, and connect the at least one new super block to the old spine blocks via the OCSs associated with the links to be disconnected.

Abstract: Described systems and methods allow protecting a computer system from malware such as viruses, Trojans, and spyware. For each of a plurality of executable entities (such as processes and threads executing on the computer system), a scoring engine records a plurality of evaluation scores, each score determined according to a distinct evaluation criterion. Every time an entity satisfies an evaluation criterion (e.g, performs an action), the respective score of the entity is updated. Updating a score of an entity may trigger score updates of entities related to the respective entity, even when the related entities are terminated, i.e., no longer active. Related entities include, among others, a parent of the respective entity, and/or an entity injecting code into the respective entity. The scoring engine determines whether an entity is malicious according to the plurality of evaluation scores of the respective entity.

Abstract: A method is provided to evaluate tests of computer program code comprising: configuring a computer to produce, in a computer readable storage device, a code filter to indicate one or more respective portions of the computer program code to respectively either omit from or to include in a determination of adequacy of results; and comparing test results with the computer program code with the one or more respective portions filtered using the code filter to respectively either omit the respective portions from or include the respective portions in the determination as indicated by the code filter.

Abstract: Localizing errors by: (i) running a testcase on a hardware processor and saving results; (ii) running the testcase on a software model of the processor and saving results; (iii) recording control flow information during the software run; (iv) determining a set of miscompare data storage locations by comparing the results from the hardware run with those from the software run; (v) based on the set of miscompare data storage locations and/or the control flow information, generating and running a modified version of the testcase that takes a different execution path when run on the software model than did the original testcase when run on the software model; and (vii) comparing the results from the hardware run and the results obtained from the modified software run to provide an indication of similarity between execution paths taken in these respective runs.

Abstract: A method for performing path-sensitive data-flow analysis for use in error checking functions includes identifying at least a first instruction and a second instruction in a control flow graph of a function. The identified first instruction and second instruction are connected by at least a first control flow path and a second control flow path. The method further includes defining a path condition between the first instruction and the second instruction as a complex disjunction including a first conjunction of predicates for the first control flow path and a second conjunction of predicates for the second control flow path.

Abstract: A method of testing software may include generating a symbolic value for a return value of a software function of a software program during mixed symbolic and abstraction execution (“mixed execution”) of the software program. Additionally, the mixed execution may maintain symbolic values, abstract values, and constraints of one or more variables of the software function. The method may also include deriving, during the mixed execution, an abstraction for the symbolic value. The abstraction may constrain the symbolic value and may be derived based on the return value of the paths that satisfy the abstraction. Further, the method may include exploring, during the mixed execution, the one or more paths of the software function that correspond to the return value based on the symbolic value, as constrained by the abstraction, such that a number of the one or more paths explored during the symbolic execution is constrained by the abstraction.

Abstract: A device performs a verification analysis of source code, where the verification analysis includes a coding rules check of the source code based on coding standards, and run-time error check of the source code. The device provides, for display, results of the coding rules check of the source code, and provides, for display, results of the run-time error check of the source code. The device provides, for display, from the results of the coding rules check of the source code, at least one of a coding rule error violation associated with the source code, or a coding rule warning violation associated with the source code.

Abstract: A method and associated systems for reducing false-positive errors in a software change-impact analysis of a basepoint variable. A processor of a computer system identifies a first generation of change-affected parts of one or more computer programs, where each identified part is affected by a change to the basepoint variable. The processor confirms the identification of each identified part by analyzing one or more characteristics of the basepoint variable and of the identified part. If the processor confirms that an identification is the product of a false-positive error, the falsely identified part is discarded. The processor then identifies a second generation of confirmed change-affected parts by repeating the procedure performed on the basepoint variable on each confirmed part of the first generation of parts. The processor continues this iterative process through additional generations until it identifies a generation that contains no confirmed change-affected parts.

Abstract: System and method for performing program-related operations over a network via a web browser. A network connection is established between a server computer and a client computer over a network. A universal resource identifier (URI) is sent from the client computer to the server computer over the network, where the URI indicates a program, e.g., a graphical program (GP), or at least a portion of a graphical program interactive development environment (GPIDE), e.g., a graphical program editor, an execution engine, a static or dynamic analyzer, and/or compiler. The at least a portion of the GPIDE is received from the server computer over the network in response to the URI, and executed in a web browser of the client computer to perform some specified functionality with respect to the GP.

Abstract: To which method on each method call order pattern included in a series of application codes executed in response to a request a method included in an application code executed in response to a request corresponds is detected; a code is generated based on identification information corresponding to the detected method on the call order pattern; and the generated code is inserted to the application code.