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: 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: Systems and methods that enhance expressibility in a programming language (e.g., Visual Basic) via relaxation of artificial restrictions and extension of delegates associated therewith, without changing the runtime infrastructure. A stub is employed that can replace an impermissible expression in the programming language, to leverage the existing permissible expressions.

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: A unique formatting scheme for object-relational mapping allows disparate applications that adopt the scheme to seamlessly access data in disparate relational databases. The formatting scheme contemplates a common format that conveys the mapping information through (i) attributes embedded with code objects, and (ii) an external mapping source. Adoption of the common format can result in several advantages for network-based client-server operations: (i) Software developers can continue programming in their existing languages. (ii) Data servers from various vendors can also continue to be developed and managed in the vendors' core programming languages. (iii) Vendors that employ client applications which have adopted the common format can consistently use various data warehouses without incurring customization costs.

Abstract: The subject disclosure pertains to interaction with one or more collections of data. Queries and domains are presented as separate entities. A number of compositional operators are provided to manipulate a generic collection of data at a low level. Query comprehensions can specify interactions with one or more collections at a higher or more intuitive level. The query comprehensions can be translated or mapped to operators that can be employed to interact with one or more data collections and return results where applicable.

Abstract: The present invention relates to a system and methodology to enable programming of generalized comprehensions in an imperative language environment. In one aspect, a system is provided to facilitate employment of user-definable and generalized comprehensions in accordance with imperative languages. The system includes a language component to enable programming of comprehension notations in an imperative language and an interface component to describe a meaning of the comprehension notations. A translation component facilitates execution of the comprehension notations in accordance with the imperative language.

Abstract: The subject disclosure pertains to layering of a plurality of type systems. A development environment and language compilers can support multiple data models and their type systems in the same program. Elements of a program such as expressions can then be associated with several types from the multiple type systems. Compilers can employ the information provided by additional type systems to improve static type checking. Furthermore, the information can be bubbled up to a user in a plurality of forms including but not limited to intelligent assistance, auto-completion, tool tips, error information, and return types to enhance the program development experience.

Abstract: Event-based processing is employed in conjunction with lazy and stateless events. Addition of any handlers is deferred until a user-specified handler is identified. Furthermore, event handlers can be composed at this time including the same properties as underlying events. More specifically, handlers specified on composite events can be composed and propagated up to a one or more related source events. As a result, handlers are not accumulated on composite events thereby making them stateless while allowing equivalent functionality upon invocation of the composed top-level handler.

Abstract: An event-driven system enables handlers to be specified for success and failure, among other things. In other words, events can be explicitly encoded with an option of returning either a success or a failure result. In this manner, asynchronous programming and events can be unified. Multiple event streams can be employed to represent success and/or exceptional values. Alternatively, a disjoint union of regular and exceptional values can be employed with respect to a single event stream.

Abstract: Event processing is transformed into query processing. Furthermore, asynchronous computation can be modeled as an event processing. Moreover, any computation that is or can be represented as push-based can be unified under an event-based processing approach subject to processing with query operators. Query processing can be performed with respect to one or more streams of events, wherein events identify a response to a raised value, among other things.

Abstract: Conversions can be applied to various asynchronous and/or concurrent mechanisms. In particular, such mechanism can be transformed into first-class events to facilitate processing with respect to first-class events including but not limited to querying. Both conventional events and asynchronous computations can be transformed to these events, for example by generating and linking a proxy event thereto.

Abstract: Systems and methods that enhance a programming language by introducing null unification on a type level in addition to a value level, for static types of both reference and value types T. An operator that adds a level of nullability (and removes such nullability) is introduced without a mention of the actual type, to steer overloading in a precise manner.

Abstract: The claimed subject matter provides systems and/or methods that facilitate replicating a state associated with a client, user, service, application, and the like. A third party service provider can support any number of services that can be concurrently requested by several clients without user perception of degraded computing performance as compared to conventional systems/techniques due to improved connectivity and mitigated latencies. A replication component can generate replicas of states associated with requested services. Further, the replicas can facilitate seamlessly interacting with the third party service provider (e.g., while transitioning between client devices). Additionally, by providing replicas of the state related information, differing third party service providers can effectuate services based upon a request from a client without regenerating the state.

Abstract: Systems and methods that analyze aggregated tagging behavior of users, and evaluate such tagging trends to identify criteria for taxonomy applications. Initially, existence of a possible trend of tagging data based on collective user behavior is determined. Subsequently, tagging trends can be examined to identify that a predetermined convergence criteria has in fact been met, and/or establish such criteria for taxonomy applications. Machine learning systems (implicitly as well as explicitly trained) can be supplied to facilitate determining the trends and the convergence criteria.

Abstract: The subject invention relates to systems and methods that augment node-based programming languages to facilitate efficient data manipulation of hierarchical data structures. In one aspect, a query or general purpose language system is provided. The system includes a query component to interact with hierarchical node-based data collections and a language extension component to augment the query component to facilitate interactions with the node-based data collections. The language extension component supplies various functions to filter the data collections at a granular level, re-shape the data collections, sort the data collections, or extend the data collections with computed nodes.

Abstract: A processing system for distributed multi-tier applications is provided. The system includes a server component that executes a replica of a client-side application, where a client component executes the client-side application. The client component captures events from the client-side application and transmits the events to the replica to validate the computational integrity security of the application.

Abstract: Systems and methods that enable consistent navigation (for a database and memory environment) in object relational mapping. This typically ensures fidelity of object graph via restrictions on collections of persistent objects (e.g., entity sets, entity refs . . . ). Moreover, a tracking component can detect changes as they occur, and only a copy of the objects that have changed can be created, to optimize operation.

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: Systems and methods that enhance expressibility in a programming language (e.g., Visual Basic) via relaxation of artificial restrictions and extension of delegates associated therewith, without changing the runtime infrastructure. A stub is employed that can replace an impermissible expression in the programming language, to leverage the existing permissible expressions.