Abstract: The described technology is generally directed towards an abstraction and file model used for subscriber service and publisher service communication. The abstraction and file model enables dynamically changing the underlying communication mechanisms and introducing optimizations such as caching (reducing latency) and batching (improving bandwidth utilization) transparently, without any change to the subscriber or publisher code. The abstraction also facilitates introducing intermediate lightweight message-oriented middleware and provides for transparently scaling communication.

Abstract: The described technology is directed towards obtaining and returning time offset data instead of current data in response to a data request. The time offset data may be limited to privileged clients only, and only provided thereto when desired, using a time offset value set by the client, for example. For example, a privileged user may request time offset data corresponding to a future time so as to preview how the data may be presented at a future time. Time offset data may be used by a system entity to fill a cache, e.g., as secondary cached data that may be used once primary cached data expires.

Abstract: The described technology is generally directed towards batching two or more data requests into a batch request that is sent to a data-providing entity such as a client data access layer coupled to a data service. Described is maintaining a mapping of the requests to requesting entities so that the responses to a batched request, which may be separately streamed, may be assembled into a batch response to the requesting entity. Also described is multiplexing a plurality of requests for the same data item into a single request, which may be added to a batch request, and de-multiplexing the single response into separate responses to each requesting entity.

Abstract: The described technology is directed towards a cache framework that accesses a tier of ordered caches, in tier order, to satisfy requests for data. The cache framework may be implemented at a front-end service level server, and/or a back end service level server, or both. The cache framework handles read-through and write-through operations, including handling batch requests for multiple data items. The cache framework also facilitates dynamically changing the tier structure, e.g., for adding, removing, replacing and/or reordering caches in the tier, e.g., by re-declaring a data structure such as an array that identifies the tiered cache configuration.

Abstract: The described technology is directed towards a structured logging technology in which events corresponding to program execution are received in a structured format and logged based upon filtering of those events. A log handler is associated with a filtering mechanism that determines whether each event matches filtering criteria and is thus to be logged by the log handler. The log handler provides matching logged events to an event sink, such as an analytic tool that consumes the events for analysis.

Abstract: The described technology is directed towards efficiently invalidating cached data (e.g., expired data) in a hash-mapped cache, e.g., on a timed basis. As a result, data is able returned from the cache without checking for whether that data is expired, (if desired and acceptable), because if expired, the data is only briefly expired since the last invalidation run. To this end, a data structure such as a linked list is maintained to track information representative of hash-mapped cache locations of a hash-mapped cache, in which the information tracks a sequential order of entering data into each hash-mapped cache location. An invalidation run is performed on part of the hash mapped cache, including using the tracking information to invalidate a sequence of one or more cache locations, e.g., only the sequence of those locations that contain expired data.

Abstract: The described technology is directed towards efficiently invalidating cached data (e.g., expired data) in a hash-mapped cache, e.g., on a timed basis. As a result, data is able returned from the cache without checking for whether that data is expired, (if desired and acceptable), because if expired, the data is only briefly expired since the last invalidation run. To this end, a data structure such as a linked list is maintained to track information representative of hash-mapped cache locations of a hash-mapped cache, in which the information tracks a sequential order of entering data into each hash-mapped cache location. An invalidation run is performed on part of the hash mapped cache, including using the tracking information to invalidate a sequence of one or more cache locations, e.g., only the sequence of those locations that contain expired data.

Abstract: The described technology is directed towards a factory identification system, in which a factory object is provided with a factory identifier (ID) that specifies information regarding a desired object that is more specific than specifying an interface. Additional construction parameters such as an object ID may be provided to further describe the desired object. Also described are object caching and reuse, and tagging the object with information that may be preserved and later used to recreate an object.

Abstract: The described technology is directed towards generating related templated files based on a set of data associated with to another class registered with a document system. These files may be edited into a source code file, a document file and a test file for any derived class. At runtime, which may include the runtime execution of the object based upon the test file, an object based upon the source code file is instantiated. Part of the object (e.g., a function) may be validated during the runtime based upon validation information in the document file.

Abstract: The described technology is directed towards having user interface objects rendered on a client device based upon provider data of at least part of a client provider graph. The client provider graph comprises a plurality of providers (graph nodes), in which each provider has provider data corresponding to user interface object data. The data of one provider has a reference set containing one or more references (e.g., edges) that each identify another provider, thus forming the graph. Client requests for other provider data are made based upon the reference set. The other provider data is received in response to the client requests, and is maintained at the client (e.g., in a client cache) to build the client graph.

Abstract: The described technology is directed towards sharing asynchronous (async) tasks between task chains, including in a way that prevents cancellation of lower-level chain entity from cancelling a shared async task. A shared async task is wrapped in multiplexer code that maintains lower-level entity identities as a set of listeners of the shared async task, and when a listener cancels, only removes that listener from the set of listeners so that the shared async task does not cancel as long as one listener remains in the set. Also described is optimization to share an async task, and wrapping tasks in cancel-checking code that prevents the task from running its work if the task is intended to be cancelled but is queued to run before the cancel request is queued to run.

Abstract: The subject disclosure is directed towards on-demand downloading of trickplay images during fast forwarding or rewinding of streaming video. A next trickplay image is selected and downloaded based upon the fast forward or rewind rate and the current location in the video. To ensure sufficient download time, the trickplay image may be chosen with a specified quality/resolution based upon historical timing data (e.g., a running average) to adaptively adjust to network bandwidth changes.

Abstract: The subject disclosure is directed towards transitioning from an existing screen (e.g., a page or the like) to a new screen, in which element(s)/control(s) of the existing screen are shared to the new screen. An existing screen acts as a source screen to provide element-related data (e.g., names) of its existing elements; the existing elements are intersected with those desired by the new/destination screen. The destination screen takes over ownership of any common elements. A navigation service may coordinate the exchange of information and the transition. The transition may include animations and/or other effects to provide a visually smooth transition or the like between screens.

Abstract: The described technology is generally directed towards a subscriber service using configurable data (e.g., a declarative configuration file) data to make service calls to publisher endpoints. Dynamic reconfiguration of the data changes the service call communication parameters without needing to bring down the subscriber server or its service, and/or without needing to modify/rewrite programs for the reconfiguration.

Abstract: The described technology is directed towards a button repeat system that allows different repeat behaviors (e.g., interval times between repeats) to be customized for any view (user interface element) and for any button. A designer specifies an interval set comprising interval times to use in an associated view to repeat a button that is pressed and held. Using global information across views, a button that is pressed and held may continue to repeat as focus changes among views. The repeating may continue without needing to reset to the first interval time of the interval set of each view as focus changes, so that, for example, a rapidly repeating button does not appear to change its repetition rate as focus changes among views.

Abstract: The described technology is directed towards having document files (e.g., a JSON object) associated with objects of a computer program. The document files may include validation information that is used during runtime to validate one or more parts of the object via validation code such as a validation function. For example, a function of an object may have one validation function that during runtime validates whether the input parameter(s) are valid (their types and/or values are correct), and another validation function that during runtime validates whether the return values from the function are valid. Also described is processing the document files into more easily readable documentation, e.g., without any source code.

Abstract: The described technology is directed towards virtual input devices that take application program-directed input from automation and/or remote devices, such as over a network, instead of via actual user input via a physical device, for example. This allows an automation framework to insert input into an application program, such as for automated testing without modifying any of the application's other components. The virtual input devices may be object instances or the like that receive their input from function calls based upon the type of input and output events, e.g., to simulate keyboard input/output (I/O), mouse or other pointer I/O, voice, gesture, and other command I/O, and so forth.

Abstract: The described technology is directed towards normalizing input received from various types of device types for providing the input to user interface (UI) elements in a unified way that reflects the invoke intent of the user. Input from different device types is classified as button input, pointer input or command input, and routed to a corresponding button provider, pointer provider or command provider. Each provider includes logic for communicating input data (e.g., events) to a UI element or elements. Based upon the input events, a UI element can execute a corresponding invoke handler to take an invoke action for that particular event.

Abstract: The described technology is directed towards server-controlled testing and/or monitoring of a client device application program. The server loads plug-in components directed towards the testing and/or monitoring operations, and instructs the client device to couple counterpart plug-in components to the client device application program. The server's plug-in components communicate with the application program's plug-in components to run the testing and/or monitoring operations, which may be automated, send queries to the client to receive responses, and send commands to the client to take actions. The server includes dashboards for interacting with the client device. The client device includes virtual input devices that allow the server to inject input into the client application program.

Abstract: The described technology is generally directed towards combining (multiplexing) two or more pending data requests for the same data item into a single request that is sent to a data providing entity such as a back-end data service. Described is maintaining a mapping of the requests to requesting entities so that a single response to a multiplexed request having data for a requested data item may be re-associated (de-multiplexed) to each requesting entity that requested that data item. Also described is batching a plurality of requests, which may include one or more multiplexed requests, into a batch request sent to a data providing entity.