Abstract: A program development framework (PDF) is described herein which allows a user to produce a program in piecemeal fashion by successively specifying program fragments. The PDF creates a new program fragment by receiving keyword information from the user that describes a new program fragment, and then identifies context information that pertains to a programmatic context in which the new program fragment appears within the overall program being created. The PDF then generates a set of candidate program fragments that satisfy the keyword information and the context information, and ranks those candidate program fragments based on ranking information. At least part of the ranking information may be based on statistical information that is produced by analyzing a corpus of previous programs produced by one or more users. The PDF then provides the ranked program fragments to the user using various user-friendly presentation strategies.

Abstract: Some implementations provide techniques and arrangements for interactive user interface operation and development. For instance, some implementations may generate a user interface data structure representing a user interface, the user interface data structure being generated based at least in part on state data and imperative programming code. Then, in response to a change in one of the imperative programming code or the state data, some implementations may update the user interface data structure and render an updated interactive graphical user interface based on the updated user interface data structure.

Abstract: This document describes techniques for contextually intelligent code editing. In at least some embodiments, the techniques are network-based and can use client-server interactions to develop programming code. For example, input to a local programming environment of a client can be transmitted to a server. A functionality at the server can inspect the input and determine programming options (e.g., programming terms and/or phrases) that are contextually valid in the local programming environment. A list of the programming options can then be transmitted to the client and presented via a user interface. In some embodiments, a selection of one of the programming options can cause the programming option to be populated to the local programming environment, e.g., as part of a user interface associated with the local programming environment. In at least some embodiments, the list of programming options can be cached locally on the client for quick retrieval.

Abstract: A privacy control system is described herein for controlling dissemination of private information by a program. The privacy control system operates by performing static analysis to determine at least one flow within the program of private information, from a source to a sink. The static analysis is particularly configured to identify two types of flow, including: (a) an unvetted flow of untampered private information from the source to the sink; and (b) a flow of tampered private information from the source to the sink, whether vetted or unvetted. The privacy control system then prompts the user to provide a privacy control decision regarding the flow. The privacy control decision governs whether actual data or anonymized data is provided to the sink, or whether the program is terminated. A runtime system then runs the program in accordance with the privacy control decision.

Abstract: A tracing just-in-time (TJIT) compiler system is described for performing parallelization of code in a runtime phase in the execution of code. Upon detecting a hot loop during the execution of the code, the compiler system extracts trace information from sequentially recorded traces. In a first phase, the compiler system uses the trace information to identify at least one group of operation components that can be operated on in a parallel manner. In a second phase, the compiler system provides instructions which allocate the group of operation components to plural processing resources. A native code generator module carries out those instructions by recompiling native code that directs the operation of a native system to perform parallel processing. The compiler system terminates a group if it encounters program data in a loop iteration that is not consistent with previously encountered predicated information (upon which it records a new trace in a sequential manner).

Abstract: The description relates to media files and more particularly to media files that include a program and a human-understandable description of the program. One example can receive executable code. This example can determine a functionality provided by the executable code. The example can also create a media file that stores the executable code and presents the functionality in a human-understandable form.

Abstract: Some implementations provide techniques and arrangements for interactive user interface operation and development. For instance, some implementations may generate a user interface data structure representing a user interface, the user interface data structure being generated based at least in part on state data and imperative programming code. Then, in response to a change in one of the imperative programming code or the state data, some implementations may update the user interface data structure and render an updated interactive graphical user interface based on the updated user interface data structure.

Abstract: A program development framework (PDF) is described herein which allows a user to produce a program in piecemeal fashion by successively specifying program fragments. The PDF creates a new program fragment by receiving keyword information from the user that describes a new program fragment, and then identifies context information that pertains to a programmatic context in which the new program fragment appears within the overall program being created. The PDF then generates a set of candidate program fragments that satisfy the keyword information and the context information, and ranks those candidate program fragments based on ranking information. At least part of the ranking information may be based on statistical information that is produced by analyzing a corpus of previous programs produced by one or more users. The PDF then provides the ranked program fragments to the user using various user-friendly presentation strategies.

Abstract: An isolation system is described for converting original product code into corresponding modified code. The isolation system operates by identifying a subset of original methods to be converted. For each such original method, the isolation system generates a modified part having at least one property with a type-safe delegate type which matches a signature of the original method. Test code, which tests the product code, can then associate a delegate instance to the thus-defined property of the original method. This prompts an execution system to dynamically execute detour code associated with the delegate instance, rather than an instrumentation of the original method, thus avoiding dependency on potentially non-deterministic functionality which would be otherwise invoked by an instrumentation of the original method.

Abstract: A finite domain approximation for symbolic terms of a symbolic state is derived, given some finite domains for basic terms of the symbolic state. A method is executed recursively for symbolic sub-terms of a symbolic term, providing a domain over-approximation that can then be provided to a solver for determining a more accurate domain. The method can be applied to a wide array of system terms, including, for example, object states, arrays, and runtime types.

Abstract: In one embodiment, a trace optimizing engine may create an optimized trace of an operation segment of a software program. A memory may store a trace of an operation segment and an inherited stack frame from the operation segment. An optimizing trace compiler may resolve a local pointer of the operation segment to a memory object and insert a guard in the trace that invalidates the trace if the local pointer does not resolve to the memory object. A just in time compiler may receive in the trace a stack pointer to the inherited stack frame, move the stack pointer to create a storage space, and store an intermediate value for a local variable in a temporary variable in the storage space.

Abstract: Described are symbolic finite automata for symbolically expressing and analyzing regular expression constraints, such as for use in program analysis and testing. A regular expression or pattern is transformed into a symbolic finite automaton having transitions that are labeled by formulas that denote sets of characters (rather than individual characters). Also described is composing two or more symbolic finite automata into a resulting symbolic finite automaton that is fully satisfiable. A constraint solver may be used to ensure satisfiability.

Abstract: A state component saves a present state of a program or model. This state component can be invoked by the program or model itself, thereby making state a first-class citizen. As the state of the program evolves from the saved state, the saved state remains for reflection and recall, for example, for testing, verification, transaction processing, etc. Using a state reference token, the saved state of the program or model can be accessed by the program or model. For example, the program or model by utilizing a state component, can return itself to the saved state. After returning to the saved state, a second execution path can be introduced without requiring re-execution of the actions leading to the saved state. In another example, the state space of an executing model is saved in order to generate inputs required to exercise a program or model.

Abstract: A marketplace system is described herein for ranking programs based, at least in part, on the assessed distinctiveness of the programs. In one implementation, the marketplace operates by: (a) accessing a set of programs; (b) extracting feature information from each of the programs; (c) generating similarity information for each program, based on the feature information; (d) ranking the programs based at least on the similarity information, to provide ranking information; and (e) providing a user interface presentation that has an effect of promoting at least one distinctive program in the set of applications on the basis of the ranking information.

Abstract: A privacy control system is described herein for controlling dissemination of private information by a program. The privacy control system operates by performing static analysis to determine at least one flow within the program of private information, from a source to a sink The static analysis is particularly configured to identify two types of flow, including: (a) an unvetted flow of untampered private information from the source to the sink; and (b) a flow of tampered private information from the source to the sink, whether vetted or unvetted. The privacy control system then prompts the user to provide a privacy control decision regarding the flow. The privacy control decision governs whether actual data or anonymized data is provided to the sink, or whether the program is terminated. A runtime system then runs the program in accordance with the privacy control decision.

Abstract: Described herein are interactive graphical user interfaces that visualize execution behavior of source code together with theoretical execution behavior of the source code together with the source code itself. Structure of the source code is analyzed to determine theoretical execution behavior of the source code. Thereafter, symbolic execution of the source code is undertaken to output an execution trace. The execution trace is shown together with the theoretical execution behavior of the source code.

Abstract: This patent relates to automatic UI rendering techniques by which specified data items can be automatically posted on a UI and rendered as interactive UI elements and/or UI sub-elements without explicit instructions for how the specified data items are to be rendered. A developer can therefore specify in a simple expression (e.g., a script) that the data item is to be posted and rendered, without having to specify how the UI elements and/or UI sub-elements are to be rendered. In response to the expression, the data items can then be automatically posted and rendered on the UI based on the data type(s) and according to pre-defined rendering instructions. The pre-defined rendering instructions need not be specific to the data items, nor provided with the expression.

Abstract: Editing functionality is described herein for creating a structured data item by dynamically presenting a key arrangement that is deemed suitable at each instance of an editing session. Each key is associated with a component of the structured data item. Upon activation of one of these keys, the editing functionality adds a corresponding component to the item being created. The editing functionality can be implemented on any user device, but is particularly suited for implementation on a handheld computing device having a limited input mechanism and a display mechanism.

Abstract: Disclosed is a process to generate and execute relevant, non-redundant test cases starting with an execution trace. An execution trace may be collected. A sequence of actions and the data involved in the actions may then be extracted from the execution trace and persisted separately from one another. Code for a non-deterministic program (“NDP”) may be generated, comprising the sequence of actions but without determining the data. A systematic program analysis of the NDP may be made, exploring possible execution paths and beginning from the path exercised by the persisted data. A new test case may be generated which fixes particular test inputs for the NDP.

Abstract: An extension of symbolic execution for programs involving contracts with quantifiers over large and potentially unbounded domains is described. Symbolic execution is used to generate, from a program, concrete test cases that exhibit mismatches between the program code and its contracts with quantifiers. Quantifiers are instantiated using symbolic values encountered during a set of exhibited runs. In this setting, quantifier instantiation is limited to values supplied to or produced by a symbolic execution. Quantifier instantiation is controlled by performing a matching algorithm that uses run-time values of input and program variables in order to guide and limit the set of quantifier instantiations. With a sufficient set of instances, test cases are derived that directly witness limitations of the auxiliary assertions.