Abstract: The subject disclosure relates to using structured query language constructs in non-structured query language domains. For example, through mathematical and logical transformation of concepts from a key, value pair domain associated with structured query language data structures to graphical-related data structures, the value originating in the structured query language domain can be modified for use in non-structured query language domains. This can open up options in analytics and can solve some of the problems associated with liner algebra.

Abstract: Embodiments enable the evaluation of injected queries within a monad. One or more operators with closures are received from a first process. The operators with closures represent one or more functions to be applied by a second process. The second process evaluates the received operators with closures to apply the functions within the monad. During evaluation, the second process converts the closures to simply typed closures. Further, the second process binds the converted closures within the monad to restrict execution of the functions. In some embodiments, the queries (e.g., sequences of one or more operators with closures) are composed using a set of query operators from the language integrated query (LINQ) framework encoded in uniform resource locators (URLs) in the representational state transfer (REST) style.

Abstract: Computation execution can be visualized and debugged. A computation such as a database query plan graph can be extracted from a database query expression. Trace points can be injected into the database query expression while preserving original behavior. Query graphs can be generated with automatic inserting of mechanisms to connect to trace points, enabling visualization of query execution lifecycle states, collection of data traces across operators, and historical debugging with replay of data sets.

Abstract: Mapping is performed between operations of an abstract asynchronous programming model and a concrete asynchronous programming model. In other words, differences between asynchronous programming models are bridged to enable interaction.

Abstract: Reshaping of streams is provided to facilitate utilizing the streams without rapidly increasing memory requirements as the size of the stream increases. The streams can be pushed to alternative storage upon being reshaped, for example, such as to a persistent storage. If the streams lose structure, for example if a hierarchical stream is reshaped into a flat structure for storage in a database, structural information can be stored along with the streams and utilized to shape the stream to its original structure upon request for data, for example. Streams can be pulled from an exposing device or application, and portions of the stream can be transformed and stored according to a set of stop elements; the stop elements can be associated with functions that take action on the stream upon reaching a stop element, such as transforming and storing a portion thereof.

Abstract: Publish/subscribe (pub/sub) systems can be interoperable. Differences between various pub/sub systems can be addressed to enable creative combination of streams from diverse pub/sub systems, among other things. More specifically, pub/sub systems can be unified to facilitate interaction, and adjustments can be made to compensate for any message stream idiosyncrasies.

Abstract: Remote provisioning of an IT network and/or associated services is provided. Hardware, software, service and/or expertise can be moved from on-premise to a remote location (e.g., central, distributed . . . ). Accordingly, at least a large degree computation can be moved to the center to exploit economies of scale, among other things. In such an architecture, computational resources (e.g., data storage, computation power, cache . . . ) can be pooled, and entities can subscribe to a particular level of resources related to a private entity IT network.

Abstract: A computer programming language, computer-readable medium and method for pattern matching over structured literals (e.g., XML literals, object literals, type literals, code literals, etc.). The programming language may have a pattern defined in an object-oriented programming language. The pattern may be a structured literal that is capable of matching a value contained in an incoming data stream. The structured literal may include one or more variables, which may be bound to the value if the pattern matches the value.

Abstract: A compositional application programming interface (API) permits non-sequential construct declaration independent of other API calls. A wrapper is applied to an imperative API to provide a compositional interface that enables arbitrary and autonomous construct declaration. Additionally, a literal syntax (e.g., code literals, graphic literals . . . ) affords a convenient declaration mechanism for such constructs.

Abstract: Architecture that extends existing types including constructed and sealed types using extension methods. Extension methods are static methods that can be invoked using instance method syntax. Extension methods are declared by specifying the keyword “this” as a modifier on the first parameter of the methods. Extension methods have all the capabilities of regular static methods. In addition, once imported, extension methods can be invoked using instance method syntax. Also disclosed are rules for importing extension methods, and extension method invocations. Extension methods are imported through using-namespace-directives. In addition to importing the types contained in a namespace, a using-namespace-directive imports all extension methods in all static classes in the namespace. In effect, imported extension methods appear as additional methods on the types that are given by their first parameter and have lower precedence than regular instance methods.

Abstract: The claimed subject matter relates to an architecture that can facilitate creation and management of an event-oriented transient network and can further manage decommission of the transient network. In particular, the architecture can construct temporary communities based upon a particular event, project, or activity; manage (e.g., filter, prioritize, or control) communications and content associated with the community; and disband the community by deconstructing the transient network according to an aging function that controls how the network decays. In addition, the architecture can leverage existing information (e.g. profile data) and content feeds associated with disparate social networking services or communities for the benefit of the temporary community.

Abstract: An API for functionally updates to data represented in trees, such as XML trees, is provided. Functional updates can be implemented using an update combinator to search for matching nodes and apply an indicated function to those matching nodes. This API can be used in non-functional languages, such as procedural languages or scripting languages. Updates are performed without side effects since a shallow clone is created for at least a portion of a tree. Nodes of the tree can be streamed into memory so that only a portion of a large tree is present in memory at any time. Artificial intelligence can be used by the API to optimize performance under the circumstances, such as optimizing based on node type that is to be updated.

Abstract: Systems and methods facilitate efficient data processing in a computer environment. Data producers and consumers are considered in aggregate rather than in isolation. In one instance, interaction between data producers and consumers is improved by integrating producers and consumers. Optimization can subsequently be performed over the combination to produce synergistic results.

Abstract: A system that can assist users to manage a personal active directory for all of their information maintained within a cloud-based environment is provided. The identity of a client that accesses data is monitored and recorded in a log. In turn, this information can be made available to the owner of the information in order to develop a desired access control list (ACL). Additionally, the system can employ a heuristic component that can automatically establish the ACL on the owner's behalf. As well, the system can track how information is being accessed (or attempted to be accessed) by other people therefore, giving the owner of the information the opportunity to restrict or allow access based upon any number of recorded factors (e.g., identity, context).

Abstract: Language-integrated query (LINQ) operators can be extended to a set of vectors associated with a digital signal processing (DSP) environment. A language-integrated query (LINQ) operator can be created to execute a change of basis for a set of vectors. LINQ operators can be further be utilized with specifically generated parameters to perform a change of basis for the set of vectors. Additionally, the standard LINQ operators can be extended to enable querying with LINQ against the set of vectors.

Abstract: Programmatic assistance is provided for dynamic typing within an integrated development environment (IDE). Types associated with late bound constructs can be inferred from static information and/or determined from design time execution. Assistance can then be provided as a function of a precise and/or speculative type. Furthermore, dynamic type assistance can be employed in conjunction with static type assistance to facilitate development of a program that supports both late and early binding, for example.

Abstract: Solving for output variable(s) of a model that includes multiple analytically related model variables. The identity of the output model variables and the analytical relationships between the model variables are separately designated. Regardless of the identity of the output variable(s), a solver framework interprets the analytical relationships and solves for the designated output variable(s). The output model variable(s) may be designated separately than the analytical relationships themselves. By simply changing the designation of the output model variable(s), the analytical relationships are reevaluated, and the output variable(s) are solved for. The solver framework itself stays the same regardless of the identity of the output model variable(s).

Abstract: Anonymous types for a programming language. Non-denotable anonymous types are types that a compiler generates on behalf of a programmer and can then be used as nominal types. Insofar as anonymous types do not have a name, they can be used only inside a method in which they are created. Additionally, an anonymous type cannot be exposed in any way outside of the method. Syntax to create an anonymous type is useful when employed with a Select operator to generate a result with a particular shape, without the need of having a regular type for it. Anonymous types are expressible such that an expression of that type can be written. Translation of an anonymous type by a compiler generates a nominal class that implements Equals and GetHashCode methods. There is equivalence of anonymous types within the same method, and conversion of an unrealized structural type into structurally compatible nominal type.

Abstract: The subject invention pertains to a system and method of extending programming languages to enable static inheritance. In particular, static subclasses can be defined which extend class functionality and/or behaviors without extending base class state. The subclasses can be specified to include static fields as well as static or instance methods and/or properties that provide a more specific interpretation of an object without extending the state thereof. Furthermore, a static subclass can be specified to provide for type aliasing. Casting is also enabled in both directions between base class type and derived class type in a convenient manner without run-time performance penalties. According to one aspect of the invention, the disclosed systems and methods can be employed to create specific programmatic context, for instance for accessing, manipulating, and type checking external data (e.g., XML).

Abstract: Modified compilers and other development tools provide implied line continuation within a sequence of syntax tokens of a programming language grammar which includes multiple semantic contexts and which uses line termination as presumptive statement termination. When source code parsing encounters a line terminator adjacent a context-dependent implicit line continuation token in an associated semantic context, an explicit decision is made whether to imply line continuation. Line continuation may also be implied in response to other specified tokens.