Abstract: Embodiments of the present disclosure provide techniques for using an inverted index in a pipelined search query. A field searchable data store is provided that comprises a plurality of event records, each event record comprising a time-stamped portion of raw machine data. Responsive to the reciept of an incoming search query, the search engine accesses an inverted index, wherein each entry in the inverted index comprises at least one field name, a corresponding at least one field value and a reference value associated with each field name and value pair that identifies a location in the data store where an associated event record is stored. Once the inverted index is accessed, it can be used to filter out a subset of the plurality of event records, wherein the subset comprises one or more event records with corresponding reference values in the inverted index.

Abstract: A device may receive configuration information for an experiment associated with optimizing an application. The configuration information may identify a group of experimental treatments and information identifying a target event. The device may identify an experimental treatment to be implemented in the application, and may implement the experimental treatment in the application. The device may collect response information based on implementing the experimental treatment. The device may detect the target event associated with the experiment, indicating that the response information is to be provided to an experiment server. The device may determine that the experiment server is unreachable and may store the response information. The response information may be stored to allow the response information to be provided to the experiment server at a later time. The response information may be provided to the experiment server to permit the experiment server to determine a result of the experiment.

Abstract: The disclosed subject matter presents a method for translating between protocols using an extended scripting language. In one embodiment ECMA-262 scripting language is extended to enable one with ordinary skill in the art to create scripts which may be used to perform diverse data manipulation including, but not limited to: file input/output, database manipulation, data identification, data translation, XML functionality, SMB functionality, email, etc. Additionally provided for is running the extended scripting language alongside a binary to manipulate data such that changes can be implemented without requiring the recoding and/or recompiling of the binary. In other embodiments, the disclosed subject matter enables the transmission of information via a webservice, with information able to be viewed on a variety of GUI's, and/or manipulated by a script wizard, autonomous script writer or a combination thereof.

Abstract: The technology disclosed describes systems and methods for implementing global profiling to track resource usage and performance for multiple threads across multiple servers for a cloud-based system. This disclosed technology provides global profiling to track resource usage across any part of a transaction as it passes between layers of a computing stack regardless of the language being executed, on logically different virtual machines across multiple servers. After data collection stops, the disclosed technology combines the results into a configurable profile view that accurately represents the order of execution of applications and methods, as though they ran on one machine. The disclosed technology builds multiple formats of the data files for different display visualizations.

Abstract: A method of branch exploration in fuzz testing of software binaries includes receiving a set of inputs of a binary program under analysis (BPUA) discovered during testing by a grey box fuzzer. The method includes re-executing the set of inputs. The method includes re-executing a concrete execution of the set of inputs in the BPUA and formation of a constraints tree in which path constraints along paths of the BPUA and conditions at branch points are recorded and marked as explored or unexplored. The method includes selecting a particular number of the unexplored branches of the BPUA. The method includes solving the particular number of unexplored branches with a constraint solver to generate a new set of the particular number of inputs. The method includes communicating the new set of the particular number of inputs to the grey box fuzzer for exploration of different branches of the BPUA.

Abstract: Testing applications on a hardware development platform. A method includes receiving user input, the user input including an executable application. The method further includes executing the executable application on an application development platform and gathering at least one of thermal or electrical power characteristics caused by executing the application on the application development platform. The method further includes. accessing operating conditions for the application development platform. The method further includes accessing a set of one or more predefined threshold end-use platform operating conditions. The method further includes scaling the thermal or electrical power characteristics caused by executing the application on the application development platform based on the threshold end-use platform operating conditions and the operating conditions for the application development platform.

Abstract: A system and method that automatically detects that a regression incident has occurred, and identifies the particular revision(s) of source code that introduced the regression incident is disclosed herein. The system and method execute one or more simulations of each revision in a window of revisions of the source code to compute values for one or more metrics. The metric values are then used to compute regression confidence values as well as a regression confidence interval—to then detect a regression incident and identify the revision that caused the regression incident. The system and method can also identify subsequent revision(s) that sufficiently fix regression incident(s) caused by a revision such that a software developer can be informed of these fixing revisions.

Abstract: Some examples relate to storing memory profile data of an application in a non-volatile memory. In an example, source code of an application may be compiled into an instrumented code for generating profile data of the application. In an example, the profile data may include memory profile data related to memory usage of the application. Next, the profile data comprising the memory profile data of the application may be generated using the instrumented code. The application may be recompiled based on the profile data that includes the memory profile data of the application. Data for storing in a non-volatile memory (NVM) may be identified from the memory profile data of the application. The identified data may be stored in the NVM.

Abstract: A Taint Modeling Function (TMF) finds abstract patterns and uses them to automate the malware detection process. TMF involves the process of statically analyzing a sequence of assembly language instructions and abstracting complex relationships among instruction inputs and outputs into a mathematical function containing a set of algebraic expressions. The set of expressions support fully automating semantic pattern detection in binary code. It deterministically generates outputs given inputs determining code block outputs, for given inputs, without executing the code. It detects code patterns automatically to spot bad coding patterns directly from the binary used to detect bugs statically in the entire application space.

Abstract: Methods for obtaining and analyzing a reduced data set are disclosed. In an embodiment, runtime dependencies between components are identified. Based on runtime dependencies, it is determined that a first component is configured to access a second component during runtime but is not configured to access a third component during the runtime. A subset of monitoring data associated with the second component is reported. A subset of the monitoring data associated with the third component is not reported. In an embodiment, a first data set associated with a component is obtained. The first data set is aggregated by monitoring of the component. A second data set, associated with the component, is simulated. The second data set is simulated based on the first data set and/or data modeling associated with the component. A characteristic and/or performance of the component is analyzed based on the first data set and the second data set.

Abstract: The disclosed system and method acquire and store performance measurements relating to performance of a component in an information technology (IT) environment and log data produced by the IT environment, in association with corresponding time stamps. The disclosed system and method correlate at least one of the performance measurements with at least one of the portions of log data.

Abstract: Systems, methods, apparatuses, and software for software testing systems in computing environments are provided herein. In one example, software modules are instantiated within an enveloping framework for replaying or recording of user activity with regards to the software modules. Based at least on the enveloping framework placed in a replay mode of operation, the enveloping framework provides replayed inputs to the software modules based on previously recorded user activity, the replayed inputs each associated with unique identifiers mapping into the previously recorded user activity. The enveloping framework monitors outputs from the software modules and correlates the outputs to the inputs using the unique identifiers. Changes are detected in operation of the software modules based in part on a comparison of previously recorded outputs from the software modules to the outputs that are determined by the software modules when using the replayed inputs.

Abstract: A computer-implemented method is disclosed which detects that new source code linked to a defect identifier has been checked in to a source code repository for a given code branch of a software application. The new source code is automatically checked in to additional code branches of the software application based on the defect identifier. For each additional code branch into which the new source code is automatically checked in, code coverage metrics are determined which indicate an extent to which application source code of the code branch is tested by its corresponding test case source code before and after the automatic check in. If a difference between the code coverage metrics indicates that code coverage for the code branch has decreased by more than a predefined threshold, a notification is transmitted that indicates a test case deficiency for the code branch.

Abstract: A method of generating program analysis data for analyzing operation of a computer program includes running a first instrumented version of machine code representing the program, the running defines a reference execution of the program, and capturing a log of non-deterministic events during the reference execution such that the machine code can be re-run in a deterministic manner to reproduce states of a processor and memory during the re-running. The method also includes generating a second instrumented version of the machine code including instrumented machine code to replay execution of the machine code representing the program and to capture and store program state information during the replayed execution, the program state information includes one or both of one or more values of registers of the processor and one or more values of memory locations used by the program.

Abstract: Embodiments relate to a virtualization layer capturing replayable execution traces of VMs managed by the virtualization layer. Execution tracing can be performed on any unit of execution managed by the virtualization layer, e.g., threads, processes, virtual processors, individual VMs, multiple VMs, etc. Traced execution units may be executing in parallel. Execution tracing involves capturing to a buffer: executed instructions, memory inputted to instructions, memory outputted by instructions, registers touched by instructions, and ordering markers. Trace data can be captured in chunks, where causality is preserved and ordering is preserved between chunks but not necessarily within chunks. The chunks may be delineated by inserting monotonically increasing markers between context switches, thus relatively ordering the chunks. Determinism may be partially provided by identifying non-deterministic events. VM tracing may be transparent to guest software, which need not be instrumented.

Abstract: An apparatus for automatically converting a control flow program into a data flow program comprises a non-transitory machine-readable medium and a translator stored in the machine-readable medium. The translator, when executed by a data processing system, enables the data processing system to (a) automatically generate a control dependency graph for a control flow program, (b) automatically generate a data flow graph based at least in part on the control dependency graph, and (c) automatically generate a data flow program based at least in part on the data flow graph. In one embodiment or scenario, the translator may also automatically insert a switch instruction into the data flow program, in response to a determination that a variable of the control flow program is defined in one control dependency region and used in a different control dependency region. Other embodiments are described and claimed.

Abstract: Techniques are disclosed for identifying a minimal operator subsets in a distributed streams application for debugging purposes. A debugging tool receives a selection of operators from a plurality of operators included in a distributed application. The distributed application executes the plurality of operators in a runtime environment. The debugging tool identifies, based on the selected operators, a subset of the plurality of operators to execute in a debugging environment. The subset includes at least the selected operators. The debugging tool executes the subset of the plurality of operators in the debugging environment.

Abstract: In one embodiment, a logging process initiates a trace of an execution flow across a plurality of processes, and creates a log context for the trace, the log context having a universally unique identifier (UUID) and an indication that the trace is to be performed as the plurality of processes are executed during the execution flow. The logging process manages passage of the log context across the plurality of processes during the execution flow, and gathers log entries from the plurality of processes based on the UUID for the trace, where the log entries were created based on the indication being within the log context. As such, the logging process may stitch the log entries into a flow execution log for the trace of the execution flow.

Abstract: Techniques for acquiring performance analysis metrics for computer-implemented functions are described herein. A computer-implemented function is instantiated on a computer system. A monitoring agent running on the computer system monitors outbound calls from the computer-implemented function and, when an outbound function call is intercepted, the agent calculates a performance metric for the outbound function. An aggregated set of performance metrics is produced, and that aggregated set of performance metrics is presented for further analysis.

Abstract: A method for allocating virtual machines (VMs) to run within a non-uniform memory access (NUMA) system includes a first processing node and a second processing node. A request is received at the first processing node for additional capacity for at least one of (a) establishing an additional VM and (b) increasing processing resources to an existing VM on the first processing node. In response to receiving the request, a migration manager identifies whether the first processing node has the additional capacity requested. In response to identifying that the first processing node does not have the additional capacity requested, at least one VM is selected from an ordered array of the multiple VMs executing on the first processing node. The selected VM has low processor and memory usage relative to the other VMs. The selected VM is migrated from the first processing node to the second processing node for execution.

Abstract: Embodiments include methods, systems, and computer program products for using static analysis to issue complaints. Aspects include generating, using a processing unit, a first complaint during static analysis of program code, wherein the first complaint corresponds to a program error. Aspects also include generating, using the processing unit, a second complaint when the first complaint is not encountered during subsequent static analysis of the program code. Aspects further include outputting, using the processing unit, the second complaint to a non-transitory computer readable medium.

Abstract: In various embodiments, a method, system, and computer program product for injecting error code include logic and/or program instructions configured to determine, by a local processor, critical points in executing code of software under test on a remote system, build, by the local processor, a testcase to invoke the software under test on the remote system, determine, by the local processor, an appropriate response action for each critical point based on an error encountered at each critical point as reported by a remote processor of the remote system, cause, by the local processor, the remote processor to inject a critical point segment into the executing code at a corresponding critical point, and receive, by the local processor, a unique identifier of each critical point segment output by the remote processor in response to injecting the critical point segment into the executing code.

Abstract: A system implements code trampolining techniques by generating custom trampoline functions, compiling the functions, and executing the compiled functions directly from a library when the corresponding native function is called. The native functions may be binary functions, such as functions in C++ code, or other languages. A code generator may read a set of functions to be implemented and generate code, such as binary code, for the destination function. In doing so, the code generator may generate code which matches the source function signature. The generated code may then be compiled into a shared library which is loaded by the process being instrumented. When the library is initiated upon subsequent calls for the native function, the trampoline mechanisms will be set up between the source function and the generated destination function to operate seamlessly with matching signatures.

Abstract: Described are techniques for determining long-term effects of an experimental change to a user experience after the end of the experiment. A control state and a treatment state of a statistical hypothesis experiment may be assigned to first and second client devices, respectively, during an experiment time period. Subsequent to the end of the experiment, presentation of the control state may be discontinued. Result data corresponding to the treatment state may be determined during the experiment time period and for a length of time subsequent to the experiment time period. Result data corresponding to the control state may be determined during the experiment time period, and for a length of time prior to assignment of the control state to the first client device.

Abstract: One embodiment provides a method, including: receiving a request to merge at least one code branch with a first code branch, wherein the at least one code branch and the first code branch comprise different versions of software code; and simulating the merge via: identifying the differences between the at least one code branch and the first code branch; generating a differences list comprising a list of (i) added code snippets, (ii) deleted code snippets, and (iii) changed code snippets, wherein code snippets are clustered in the differences list by difference chunks comprising connected code snippets; and building a relationship graph comprising a plurality of nodes and a plurality of edges, wherein each of the plurality of nodes represent a difference chunk and wherein each of the plurality of edges comprise a relationship between two of the plurality of nodes; each of the plurality of edges comprise a cost vector.

Abstract: A communication apparatus includes a receiver configured to receive metadata, the metadata including information associated with update data capable of being executed after the receiver has received the metadata, and a determination part configured to determine whether an update of the update data is executable in accordance with the metadata. When the determination part has determined that the update is executable, the update is executed.

Abstract: Techniques are disclosed for allowing users to access data libraries associated with multiple, isolated runtime environments (RTEs). A web query application receives a query and determines an RTE to execute the query against. The web query application determines whether a current RTE matches the determined RTE. If the web query application determines that the current RTE does not match the determined RTE, the web query application configures a server computing system to access the determined RTE and execute the query against data libraries associated with the determined RTE. If the web query application determines that the current RTE matches the determined RTE, the web query application executes the query against the data libraries associated with the current RTE.

Abstract: Particular embodiments establish static redirection of a function that is a member of a class to an alternate implementation of the function. A software tool executing on a computer server receives an executable file for an application and a location for an alternate implementation of the function. The function may be written in Objective C. The software tool can be used to locate a structure for the function by traversing serialized metadata in the executable file. The software tool can then be used to modify the metadata in the executable file by updating the value of a selector indicating the location of a current implementation of the function to indicate a location of the alternate implementation. The selector may be included in a element of the structure for the class method. Finally, the application may provide the modified executable file for installation on client devices.

Abstract: This disclosure provides a computer-implemented method for monitoring an application at runtime. The method comprises building up a calling relationship graph for at least one type of system method called at runtime, by checking a stack trace generated when the application is running. An application method of the application that directly or indirectly calls this type of system method is represented as a node in the calling relationship graph. The method further comprises determining one or more target nodes in the calling relationship graph by analyzing the structure of the calling relationship graph. The method further comprises inserting callback methods into application method(s) of the application corresponding to the one or more target nodes only in a calling side. The method further comprises monitoring the application at runtime by using said callback methods.

Abstract: An information processing apparatus comprises: an insertion unit that inserts, into a class file that corresponds to one application, a first bytecode for tallying information about a resource used by an object generated by execution of a bytecode that is included in the class file; and a tallying unit that, if an application generates an object, tallies information about a resource used by the object generated by the application, wherein the one application that has executed the first bytecode is identified by execution of the first bytecode, the one application thus identified and information about a resource used by a generated object are registered to a storage unit in association with each other, and the tallying unit tallies a resource usage amount for each application based on the information registered to the storage unit.

Abstract: Asynchronous operations associated with a request such as synchronous threads, runnable elements, callable elements, and other invokable objects are tracked to determine the metrics about the request and operations. The present technology tracks the start and end of each asynchronous operation and maintains a counter which tracks the currently executing asynchronous operations. By monitoring the request, the start and end of each asynchronous operation associated with the request, and the number of asynchronous operations currently executing, the present technology may identify the end of a request by identifying when the last asynchronous operation associated with the request ends. In some instances, the present technology identifies the end of a request when a counter which tracks the number of asynchronous operations executing reaches a value of zero after the first asynchronous operation has already begun.

Abstract: For each of a plurality of wrapper logic components, a metric is determined from content of reports received from user electronic devices that characterizes performance of the wrapper logic component when executed by the user electronic devices to monitor a feature of an application during execution of the application by the user electronic devices. A set of the wrapper logic components is selected that excludes from the set any of the wrapper logic components having performance characterized by the metrics that does not satisfy a first defined rule. The set of wrapper logic components and the application are combined to form a modified application with the wrapper logic components of the set configured to monitor features of the modified application when executed by user electronic devices.

Abstract: According to one embodiment, an information processing method including: detecting by a time information acquiring unit a start and an end of an access of a memory access unit to a target memory, the access of the memory access unit being due to instructions of an instruction issuer, and acquiring by the time information acquiring unit a memory access time being a time from the start of the access till the end of the access; calculating by a computation amount acquiring unit, based on the instructions of the instruction issuer, a computation amount of a computing unit from the start of the access till the end of the access; and evaluating by an evaluation unit, based on the memory access time and the computation amount, computing performance of the computing unit from the start of the access till the end of the access.

Abstract: Comprehensive techniques identify data leaks in software applications using Asset Flow Analysis (AFA) to determine whether critical data leaves a system through an exit point such that the data is no longer protected by mechanisms of the system. A novel data extrusion mechanism makes use of a relevant subset of all the possible data paths detected by AFA using a knowledge base of critical business functions and critical database content. The system checks if any code performs read access to critical business data and subsequently transfers this data beyond the control limits of the target system. The knowledge base can be extended by configuring which database content is to be regarded as critical in any given organization. The approach is particularly valuable in protecting systems that manipulate, distribute, or store sensitive information associated with financial, business, or personal data, including SAP® ABAP™ software applications.

Abstract: Executable code of an application package is decompiled to provide a decompiled application package. Features of the application package are identified based on content of the decompiled application package. A set of wrapper logic components are selected from among a library of wrapper logic components based on the features of the application package. The decompiled application package is disassembled to provide disassembled code. Wrapper program hooks are inserted into the disassembled code to provide modified disassembled code. The modified disassembled code is assembled to provide modified assembled code. The wrapper logic components of the set are combined with the modified assembled code to form a wrapped application package including executable code from the modified assembled code and executable code from the wrapper logic components of the set that intercept calls by the executable code from the modified assembled code.

Abstract: A computer system that is programmed with virtual memory accesses to physical memory employs multi-bit counters associated with its page table entries. When a page walker visits a page table entry, the multi-bit counter associated with that page table entry is incremented by one. The computer operating system uses the counts in the multi-bit counters of different page table entries to determine where large pages can be deployed effectively. In a virtualized computer system having a nested paging system, multi-bit counters associated with both its primary page table entries and its nested page table entries are used. These multi-bit counters are incremented during nested page walks. Subsequently, the guest operating systems and the virtual machine monitors use the counts in the appropriate multi-bit counters to determine where large pages can be deployed effectively.

Abstract: The disclosed embodiments provide a system for processing data. During operation, the system obtains an attribute of a stack trace of a software program. Next, the system uses the attribute to select an address-translation instance from a set of address-translation instances for processing the stack trace. The system then provides the stack trace to the selected address-translation instance for use in translating a set of memory addresses in the stack trace into a set of symbols of instructions stored at the memory addresses.

Abstract: Generally in a computing environment, executing work based on time (i.e. according to a predetermined schedule) is a common need. However, in cloud based systems, scheduled work may be expensive to customers as generally customers rent system resources. Thus, having a processor dedicated to performing actions that have been pre-scheduled can be expensive. This application describes using a continuation-based runtime for scheduling time-bound and/or periodic work in a distributed (i.e. cloud) system. A system architecture and computer-implemented method are described that deploy an environment-independent action to a remote-based system (such as a cloud computing system, for example). The action is limited to using a predetermined amount of resources and is limited to simple, non-cpu intensive orchestrations of network calls.

Abstract: The disclosed embodiments relate to a system that gathers telemetry data while testing a computer system. During operation, the system obtains a test script that generates a load profile to exercise the computer system, wherein a running time of the test script is designed to be relatively prime in comparison to a sampling interval for telemetry data in the computer system. Next, the system gathers telemetry data during multiple successive executions of the test script on the computer system. The system merges the telemetry data gathered during the multiple successive executions of the test script, wherein the relatively prime relationship between the running time of the test script and the sampling interval for the telemetry data causes a sampling point for the telemetry data to precess through different points in the test script during the multiple successive executions of the test script, thereby densifying sampled telemetry data points gathered for the test script.

Abstract: A computer implemented anti-tamper system employing runtime profiling of software in order to decide where to inject integrity checks into the software, to enable verification of whether or not the software has been tampered with. Runtime profiling and analysis is used to record information about the application, in order to establish the locations and targets of runtime integrity checks in order to optimize protection security, while minimizing the performance penalty and the need for hand configuration.

Abstract: Methods, systems, and computer program products are included for performing module unloading in a protected kernel environment. A method includes loading a module into a kernel, the module including an exit function. The kernel provides, to a hypervisor, a memory location corresponding to the exit function of the module. A kernel protection feature is activated. After activating the kernel protection feature, the hypervisor detects an attempt to execute the exit function. The hypervisor determines that the attempt to execute the exit function corresponds to the memory location provided to the hypervisor. Based on the determining, the hypervisor allows execution of the exit function.

Abstract: The present disclosure describes systems and methods for processing security sensor data that enhances the ability of a user to quickly and efficiently review portions of the sensor data streams.

Abstract: Techniques for generating, storing, and using service call graphs are provided. In one technique, trace data items generated by different services are correlated to generate a service call graph. Trace data indicates when certain services are called and their respective latencies as a result of a client request. A service call graph may reflect a single trace or multiple traces over a particular period of time. A service call graph may be analyzed to inform administrators of a web site how a web application and the services it relies on are performing. A service call graph may be used to determine whether there are sufficient resources to support a projected increase in traffic to a web application. A service call graph may be used to estimate a cost of a web application. Multiple service call graphs may be compared to determine one or more root causes of a performance problem.

Abstract: A memory heap management facility is provided that is able to perform various management tasks, including, but not limited to, garbage collection, compaction, and/or re-ordering of objects within a heap. One or more of these management tasks improve system performance by limiting movement of pages in and out of virtual memory. The garbage collection technique selectively performs garbage collection such that certain objects, such as old but live, infrequently referenced objects, are not garbage collected each time garbage collection is performed.

Abstract: Embodiments include methods, computer systems and computer program products for performing superscalar out-of-order processing in software in a computer system. Aspects include: loading opcodes into an analysis thread of the computer system, analyzing opcodes to identify certain non-independent opcode snippets, distributing non-independent opcode snippets to separate threads of computer system, instructing each of separate threads to execute each of non-independent opcode snippets, respectively, and collecting results of executions of each of separate threads by a consolidation thread.

Abstract: Methods and systems for analyzing and improving performance of computer codes. In some embodiments, a method comprises executing, via one or more processors, program code; collecting, via the one or more processors, one or more hardware dependent metrics for the program code; identifying an execution anomaly based on the one or more hardware dependent metrics, wherein the execution anomaly is present when executing the program code; and designing a modification of the program code via the one or more processors, wherein the modification addresses the execution anomaly. In some other embodiments, a method comprises collecting one or more hardware independent metrics for program code; receiving one or more characteristics of a computing device; and estimating, based on the one or more hardware independent metrics and the one or more characteristics, a duration for execution of the program code on the computing device.

Abstract: A computer-implemented method of reducing impact of performance data gathering on execution of instrumented code comprises gathering respective performance data for each of a plurality of routines in the instrumented code over a plurality of execution instances of the instrumented code. The method also comprises determining that the gathered performance data for the at least one selected routine follows an identified pattern for at least one selected routine from the plurality of routines and, in response to determining that the at least one selected routine follows an identified pattern, removing instrumentation associated with the at least one selected routine.

Abstract: A circuit includes don't-care a code-value calculation circuit to calculate third code-values by coding a signal sequence in accordance with a coding scheme; a first sequence-detection circuit to detect a first sequence based on comparison of a first code-value with a difference between the current third code-value and a fourth code-value that is the third code-value preceding the current third code-value by a length of the first sequence; an expected-value calculation circuit to calculate an expected value of the third code-value at the end of the third sequence based on a second code-value and a fifth code-value that is one of the third code-values; and a determination circuit to detect the end of the second sequence based on a length of a fourth sequence, notify an expected-value calculation circuit of the detection of the second sequence, and output a detection signal indicating detection of a detection-target sequence.

Abstract: The disclosed subject matter presents a method for translating between protocols using an extended scripting language. In one embodiment ECMA-262 scripting language is extended to enable one with ordinary skill in the art to create scripts which may be used to perform diverse data manipulation including, but not limited to: file input/output, database manipulation, data identification, data translation, XML functionality, SMB functionality, email, etc. Additionally provided for is running the extended scripting language along side a binary to manipulate data such that changes can be implemented without requiring the recoding and/or recompiling of the binary. In other embodiments, the disclosed subject matter enables the transmission of information via a webservice, with information able to be viewed and/or manipulated on a variety of GUI's.

Abstract: A computer-implemented method is disclosed which detects that new source code linked to a defect identifier has been checked in to a source code repository for a given code branch of a software application. The new source code is automatically checked in to additional code branches of the software application based on the defect identifier. For each additional code branch into which the new source code is automatically checked in, code coverage metrics are determined which indicate an extent to which application source code of the code branch is tested by its corresponding test case source code before and after the automatic check in. If a difference between the code coverage metrics indicates that code coverage for the code branch has decreased by more than a predefined threshold, a notification is transmitted that indicates a test case deficiency for the code branch.