Abstract: The subject disclosure relates to resource optimization in a computing system by leveraging the asynchronous nature of event-based programming. Events arriving on respective event streams are intercepted by mechanisms as described herein that regulate the flow of events from the event stream(s) to their corresponding programs according to a desired resource usage level associated with processing of the programs. Event flow control is performed as described herein via operations on events such as buffering, queuing, desampling, aggregating, reordering. As additionally described herein, a resource usage level for a given processing entity can be determined based on considerations such as program priorities, power profiles or other resource profiles, and resource cost analysis. Further, techniques for extending input regulation as described herein to the case of load distribution among multiple processing nodes are provided.

Abstract: A documentation system is described herein that automatically generates documentation for software code from tests that verify the correct operation of the software code. Software development teams often write automated tests (software that tests the software being shipped), such as unit tests. When written correctly, these tests are a written contract of what the software is supposed to do. The documentation system can use static and dynamic analysis in combination with annotations in the test code to extract the contract from these tests and leverage the extracted information to automatically generate the documentation. The system can then visually display this information in a textual or graphical way. Thus, the documentation system generates documentation that more accurately reflects how software code is expected to operate, without introducing significant burdens into the software development cycle.

Abstract: A fuzz testing system is described herein that represents event sources, channels, processors, and consumers as first-class entities in an application. Abstracting event-related entities allows fuzzing through injecting, dropping, reordering, and delaying events from within the application. This translates into the ability to localize the areas under test and perform fuzzing in a systematic manner. In some embodiments, the fuzz testing system tests concurrent asynchronous and event-based code, and can generate event streams based on a given statistical distribution. Representing events, event sources, processors, and sinks as first-class objects provides easy access to the event handlers and facilitates implementing fuzzing by introducing event processors between the source and the sink. Thus, the fuzz testing system improves the testability of applications and APIs with asynchronous behavior and provides a uniform framework for introducing fuzz testing into such applications.

Abstract: Object instance annotation technology is disclosed. This technology is capable of annotating any number of instances for any number of objects. Object instance annotations can be of various types, and annotations can serve as data extensions. Objects are enabled for annotation either by developers, or, alternatively, automatically by a programming language or framework. Furthermore, an interface is provided for annotations. This interface has a variety of operations, some of which allow for adding, retrieving, or removing annotations. Annotations can be reference types or even value types. They may also be private class types. Once object instances are enabled for annotating, and the interface is set up, this interface can annotate a multitude of different kinds of objects. For example, it can annotate generic objects, XML trees, CodeDom trees, and so on.

Abstract: A type system employing structural subtyping is disclosed herein. A core type system supports several structural types, such as stream, choice, intersection and sequence. Also part of the core type system is a new invariant type, which denotes values whose dynamic type is the same as its static type, and type restrictions for limiting a range of a base type. Furthermore, a streamlined structural version of delegates, called structural delegates and a validation method thereof are introduce into the type system. To further facilitate type safety, strict statically checked interface casts are introduced.

Abstract: A type system employing structural subtyping is disclosed herein. A core type system supports several structural types, such as stream, choice, intersection and sequence. Also part of the core type system is a new invariant type, which denotes values whose dynamic type is the same as its static type, and type restrictions for limiting a range of a base type. Furthermore, a streamlined structural version of delegates, called structural delegates and a validation method thereof are introduce into the type system. To further facilitate type safety, strict statically checked interface casts are introduced.

Abstract: A compiler deployed as a component of an integrated development environment (“IDE”) is adapted to transform source code into target code that is correct by construction by complying with approved patterns described by an external configuration file which is utilized to parameterize the generation of the target code by a code generator. The approved patterns can express various design requirements, guidelines, policies, and the like that are acceptable for the target code to include as well as those which are unacceptable. A rules generator that applies regular tree grammar is configured to encapsulate the approved patterns in the external configuration file using a formal description that is machine-readable by the code generator. A source code translator is alternatively utilized to transform non-compliant source code into compliant source code that adheres to the approved patterns.

Abstract: A sensor network may be created by collecting information from a plurality of mobile devices, such as cellular telephones. The mobile devices use sensors, such as microphones, cameras, accelerometers, biometric readers, etc. to detect the sensory information. Sensory output related to detected sensory information may be transmitted from a mobile device to a receiver that receives the sensory outputs. The received sensory outputs from a plurality of mobile devices may be aggregated to generate aggregated data, which may be transmitted to one or more receivers that use the aggregated data to perform a function and/or present the aggregated data to a user. Additionally, the aggregated data may be reviewed by a reviewer component that can create (revised) detection instructions regarding how one or more mobile devices are to detect sensory information and/or what sensory information to detect (e.g., to make resulting aggregated data more relevant).

Abstract: Data is requested by an XML application conforming to the XML data model. The data is stored in an SQL database conforming to the relational data model. A mapping component transforms the XML query into an SQL query using a mapping component comprising instructions obtained from an instruction set defined by a mapping algebra. The transformed operation is used to retrieve the data. Once retrieved, the algebraically defined mapping component transforms the SQL data from data conforming to the relational data model to data conforming to the XML data for use in the XML application.

Abstract: A program execution engine that facilitates generic type variance verification is provided. The execution engine receives a program executable in the form of intermediate language (IL). The program executable can be based on code that includes expression(s) with generic type(s) which have been identified as requiring variance verification (e.g., covariance and/or contra-variance). The execution engine includes a variance verification component that dynamically determines whether value(s) associated with the generic type(s) identified as requiring variance verification comply with the particular variance verification requirement. The variance verification component can provide error information (e.g., throw an exception), if the specified variance is not safely compliant. Variance verification can be based on static checking which places the burden on a source language compiler to emit the run-time checks in intermediate language (IL), if run-time checked variance is required.

Abstract: Techniques and systems for determining a first entity's social network are provided herein. Data is extracted from one or more data sources associated with the first entity. Once data is extracted, a role of a second entity may be inferred using inference algorithms, rules, keywords, and/or tags in the data extracted. The first entity's social network may be determined by linking the first entity to the second entity and the second entity's role(s) in relation to the first entity. It will be appreciated that the first entity may also search his/her/its network and/or other entities' social networks if the first entity has been granted access by the other entities, for example. Additionally, information about entities found during the first entity's search may be added to a data source associated with the first entity.

Abstract: An operation (such as a relational query) may be processed on a processing engine (such as a relational database server) on behalf of a client. A conventional processing involves the delivery of the operation to the processing engine, which executes the entire operation to completion and returns a result data set. It may be more efficient to allocate part of the operation to be performed on the client, but a developer may be unable or unavailable to rewrite the operation in a distributed manner. Instead, the operation may be automatically partitioned into a pre-engine client portion, a processing engine portion, and a client portion, and the instructions of each portion may be automatically allocated respectively to the client, the server, and the client. The partitioning may be adjusted to conserve computing resources, such as bandwidth and storage, and the instructions may be reordered to improve the processing of the operation.

Abstract: Data source queries may be specified in various languages, such as SQL, XQuery, and object-oriented languages, and each language may have various linguistic features that enable different types of queries. It may be advantageous to formulate mixed language queries having portions specified in a first language and portions specified in a second language, and to provide mixed language query evaluation components that can parse portions of queries of different languages. It may also be advantageous to permit the translation of single language queries into multiple languages to be parsed by such mixed language query evaluation components. Such techniques may permit queries to utilize linguistic features and processing techniques of one language that are less efficient, less direct, or simply unavailable in another language.

Abstract: Queries targeting various data sources are processed in a query processing pipeline that parses the query into a set of operations (e.g., an expression tree or a translated SQL query) using a set of query operators, each handling a particular type of operation. The query operators are often designed in an unspecialized manner, such that each query operator handles one query operation in an atomic, generic manner (e.g., sorting generic data items for an ORDER BY clause.) More efficient queries may be devised by including specialized queries that operate in common but special cases, such as a sorting of a particular data type (e.g., a floating-point number sort) or a sequence of two or more operations that are often performed together (e.g., a WHERE test of an attribute followed by a SELECT of the same attribute.) The use of specialized operators may result in the formulation of more efficient queries.

Abstract: Queries against data sources (such as language-integrated queries to be applied against relational databases) may be prepared for processing by a query processing pipeline. This pipeline performs services including transforming the query into a form more easily applied by the data source, e.g., into SQL, by matching query terms with query operators configured to handle various query operations. Many query processing pipelines include single-item query operators that perform individual operations (e.g., an updating query operator that specifies an updating of individual records of a table.) An integrated query pipeline may be devised that includes both single-item query operators and multiple-item query operators that specify operations on sets of data items.

Abstract: The utilization of data services (such as web services) may involve the invocation of services, which may reduce performance and overburden the server. In some scenarios, the invocation may be specified in a language that does not support batch invocation, but it may not be feasible to re-code the invocations in a language that supports batching. Instead, the service invocations may be automatically translated into a batch logic specified in a batch-capable language and sent to the service as a batch. For example, a local proxy may receive a language-integrated query having two or more service invocations, compile the query into an expression tree including the two or more invocations, and send the expression tree to the service host to achieve the batch processing of the service invocations.

Abstract: Application remote control is affected across execution contexts. In one instance, input can be acquired from controlled applications and employed by other applications. Additionally or alternatively, remote control can be employed to test applications while minimizing unintended changes to applications under test caused by observation.

Abstract: Systems and methods that transform an input stream to an output stream by employing a hybrid of declarative features and procedural features. A transformation component includes a declaration component that identifies data types, which enables users to define customized event(s) whereupon user functions can be called, and a procedural component that executes the logic of the functions that are called to perform operations of the functions.

Abstract: An arrangement by which pointers may be represented in a restricted software execution environment that provides access to only reference types but not pointers is realized by modeling both pointers and value type boxing using a set of boxes (i.e., containers) which describe how to retrieve the value associated with the pointer, and emitting code for accessing the set of boxes. A decompiling and recompiling process is utilized in which code arranged to run in an execution environment that supports pointers is scanned to reveal pointer and boxing usage. In one illustrative example, code is responsively emitted to create one or more specific boxes. At runtime in the restricted execution environment, an instance of a box class is created to thus emulate a pointer to the value.

Abstract: A polymorphic software architecture is provided by which the shape of the architecture is enabled to be dynamically changed by splitting and fusing various architectural components (which may also be called “elements”) responsively to the environment in which the software executes, without changing the application's code. The splitting and fusing points determine, for example, the partitioning of functionality and data across architecture components, communication among the components, and the allocation of resources to the components. A profile of an end-user, or a profile of the runtime environment that supports the end-user, may be used to drive the shape of the software architecture so that overall design goals are met upon initial software deployment, and maintained as the profiles change.