Patent application number | Description | Published |
20080215450 | REMOTE PROVISIONING OF INFORMATION TECHNOLOGY - 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. | 09-04-2008 |
20080215603 | SERIALIZATION OF RUN-TIME STATE - The claimed subject matter provides a system and/or a method that facilitates re-locating a web application associated with a network service utilizing a portion of serialized data. The network service can be any collection of resources that are maintained by a party (e.g., third-party, off-site, etc.) and accessible by an identified user over a network (e.g., WAN, Internet, etc.). An interface component can receive a portion of serialized data with transparent structure related to an application specification. A hydrate component can create a web application independent of a network service based at least in part upon the serialized data, the web application has state within the network service. | 09-04-2008 |
20080243764 | GROUP JOINS TO NAVIGATE DATA RELATIONSHIPS - A group join query facilitates navigation of relationships (e.g., one-to-many or many-to-one) across a plurality of data collections. Such a query operator produces nested or hierarchical results that capture the arguments passed thereto. If desired, the nested results can be flattened to simulate conventional relational database results. | 10-02-2008 |
20080244516 | VARIABLE CAPTURE IN OBJECT ORIENTED LANGUAGES - Systems and methods facilitate variable capture with respect to closures in object oriented programming languages. In particular, multiple copies of closure variables are generated such that lifetime of variables is defined by variable scope. However, if a previous version of a variable exists, a newly created variable is initialized with the value of the previous version. | 10-02-2008 |
20080256512 | OUT OF BAND DATA AUGMENTATION - Systems and methods facilitate data augmentation in a computer environment. Data collections of various forms are altered out of band with at least one augmentor specifying alterations thereto. The alterations are applied to an associated collection of data such as programmatic code. In this manner, data can be modified, extended and/or removed from the collection to enable specialization and/or personalization, among other things. | 10-16-2008 |
20080262992 | TYPE INFERENCE FOR OBJECT-ORIENTED LANGUAGES - Systems and methods facilitate type inference in a computer-programming environment. Type inference can be applied to generic method or function invocation in object-oriented languages to determine a type argument list left implicit by a programmer. One or more type arguments can be identified as a parameter type to which all other types in a set of associated parameter types can be converted. | 10-23-2008 |
20080281786 | PRODUCER/CONSUMER OPTIMIZATION - 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. | 11-13-2008 |
20080282238 | STATIC TYPE FOR LATE BINDING - A static type computer language provides optional dynamic typing triggered by a unique static type. The unique static type can be utilized anywhere other types can be employed to identify programmatic elements that are late bound. As a result, static types can be analyzed at compile time while deferring analysis of dynamic types until runtime. | 11-13-2008 |
20080282260 | DYNAMIC DISPATCH FOR CLASSES AND INTERFACES - Dynamic dispatch for classes and interfaces is encapsulated in a class-less scripting language. A plurality of mechanisms are employed to facilitate dynamic polymorphism. One or more target language constructs such as dictionary objects, prototype objects and/or derived types are utilized to capture class and interface method implementations. These constructs are subsequently referenced at runtime to invoke appropriate code. | 11-13-2008 |
20080295070 | NATIVE ACCESS TO FOREIGN CODE ENVIRONMENT - Mechanisms afford access to a foreign code environment from a native computer programming language. A program includes an attribute or declarative tag identifying foreign code associated with a native program construct. The attribute is subsequently morphed into script code that matches the calling convention and/or semantics of a related native construct. | 11-27-2008 |
20080295083 | EXPLICIT DELIMITATION OF SEMANTIC SCOPE - Systems and methods are provided with respect to computer programming. Program behavior can be tuned to provide a seamless mixture of semantic behavior across a single program language syntax. Semantic behavior can be explicitly specified at arbitrary levels of syntactic granularity (e.g. expressions, members, types, compilation units . . . ), wherein semantic scope is commensurate with the specified level of granularity. | 11-27-2008 |
20080320440 | FULLY CAPTURING OUTER VARIABLES AS DATA OBJECTS - Providing for read/write access to captured free variables expressed as environment data objects is disclosed herein. By way of example, free variables can be rewritten as a field of a private class, and accessed via an instance of the private class captured within the environment data object. In such a manner, no need of a placeholder or proxy function is required to access the free variable. Consequently, the subject innovation provides a simplified method for capturing free variables within expression trees and providing read/write access to such variables. | 12-25-2008 |
20080320444 | LATE BOUND PROGRAMMATIC ASSISTANCE - 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. | 12-25-2008 |
20080320453 | TYPE INFERENCE AND LATE BINDING - A type inference option is available for a computer programming language. The option acts as a switch to specify whether or not type inference is applicable (e.g., on or off). Type inference can be employed in conjunction with late binding or options therefor. In this manner, a computer program can be developed with the convenience of type inference and the flexibility of late binding while still maintaining at a degree of type safety. | 12-25-2008 |
20090006429 | STREAMLINED DECLARATIVE PARSING - Programming mechanisms for data parsing facilitate both clear code specification and efficient execution. Declarative style code can be employed to enable clear and concise specification of data parsing. Further, an efficient parsing approach can be utilized that enables processing of a data structure without first materializing the entire structure to memory. More specifically, streaming and/or selective materialization of portions of data to memory can be employed. | 01-01-2009 |
20090006450 | MEMORY EFFICIENT DATA PROCESSING - Memory efficient data processing is provided in a computer environment. A data representation or description is utilized to reduce memory footprint. A data structure can be serialized iteratively utilizing the representation rather than first loading the entire data structure to memory. Portions of the data structure can be materialized to and removed from memory as function of operational need. | 01-01-2009 |
20090024683 | N-Dimensional Coordinates Conversion - Aspects of the subject matter described herein relate to converting between polar and rectangular coordinates. In aspects, the Nth polar angle is measured upward from the sine-projection of the Nth component in the (N−1)th dimension. The last polar coordinate is zero if and only if the corresponding last rectangular coordinate is zero. The conversion may be applied in any number of dimensions without re-writing the conversion logic. | 01-22-2009 |
20090024986 | RUNTIME CODE MODIFICATION - Source languages are translated to target dynamic programming languages. Runtime functionality including reflection and/or dynamic code modification exposed by a source language is mapped to a dynamic language implementation such as that of a script language. Target language dynamism is leveraged to efficiently support runtime functionality in a source language that is more static, for example. | 01-22-2009 |
20090030659 | SEPARABLE INTEGRATION VIA HIGHER-ORDER PROGRAMMING - Separable integration is provided for simulation contexts where modeling and integration can be considered separately when programmatically implementing the simulations, for example. Thus, modeling concepts can be defined relating to the simulation, and integration of the modeling concept can happen separately to provide more variety to meet modeling specifications. In one embodiment, a state-space form equation can be computed for a modeling concept equation (an equation of motion, for example) and an integration scheme can be applied to the state-space form equation regardless of the modeling equation from which it was computed. In this regard, integration can be focused on to provide a plurality of schemes for different contexts, for example. | 01-29-2009 |
20090030869 | VISUALIZATION TECHNIQUES FOR IMPRECISE STATEMENT COMPLETION - When a user enters text into an application, the application can utilize an auto-complete feature to provide the user with estimations as to a complete term a user is attempting to enter into the application. Visualization can be provided along with an estimation to disclose the likelihood the estimation is what the user intends to enter. Furthermore, a rationale can be provided to the user for the reason an estimation was provided to the user. | 01-29-2009 |
20090030902 | SCHEMATIZED DATA INTELLIGENT ASSISTANCE FOR DEVELOPMENT ENVIRONMENTS - Intelligent assistance functionality is provided in development environments and/or other editors for schematized data. Input of a trigger character sequence can initiate an intelligent assistance box having data corresponding to a related schema. Thus, the intelligent assistance data can be dynamic as schematized data can change; the data can be queried from the schema as requested to facilitate this end. In one embodiment, the data can be an extensible markup language (XML) schema having a plurality of elements. In this regard, syntax can be entered into a development environment to effectuate an intelligent assistance box comprising the elements of the schema; a root level element can be displayed for an initial trigger character sequence. After selecting the element, another trigger sequence can be input to facilitate querying the schema for next level elements, and so on. | 01-29-2009 |
20090030926 | COMPOSITE NESTED STREAMS - 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. | 01-29-2009 |
20090037876 | VISIBLE WHITE SPACE IN PROGRAM CODE - White space is made visible in a code editor to facilitate identification thereof via color, symbols, characters and/or the like. Further, white space can be explicitly identified and distinctly presented of various types including significant, insignificant and editor introduced. White space information can also be employed to aid code compilation and/or processing. | 02-05-2009 |
20090049421 | AUTOMATIC AND TRANSPARENT MEMOIZATION - Functions are memoized automatically and transparently. Memoized code can be injected automatically within a program to facilitate efficient and/or expeditious execution thereof, among other things. The memoized code can intercept calls to an original function and return values in accordance with the code. Accordingly, callers of the function need not do anything special and can invoke the function without knowledge of it being memoized. | 02-19-2009 |
20090063555 | FILE FORMATS FOR EXTERNAL SPECIFICATION OF OBJECT-RELATIONAL MAPPING - 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. | 03-05-2009 |
20090077120 | CUSTOMIZATION OF RELATIONSHIP TRAVERSAL - An object-relational mapping mechanism facilitates customized relationship traversal. The mechanism can override default loading behavior with custom functionality (e.g., eager loading, lazy loading . . . ) specified by a programmer, for example. In other words, the object-relational mapping mechanism includes an extensibility point or hook for customization. | 03-19-2009 |
20090112975 | PRE-FETCHING IN DISTRIBUTED COMPUTING ENVIRONMENTS - Client-side performance is optimized through server-side pushing of content. Portions of content are requested and retrieved as required by a client-side application. Moreover, content likely to be needed in the near future is pre-fetched and pushed to the client. This is beneficial from an overhead standpoint since all content need not be provided to the client at once. Rather, content provisioning is throttled based on need, and wait time is mitigated by pre-fetching. | 04-30-2009 |
20090113250 | SERVICE TESTING - Communication symmetry is leveraged to facilitate testing of network services. To identify, isolate, understand, and resolve problems a test client is employed. In accordance with one aspect, a service can be provided for execution on a service consumer while the test client resides on a service provider. Roles are reversed to provide more testing freedom on the provider side and less intrusion on the consumer side. Additionally or alternatively, a service and/or test client can be shipped to consumers to aid testing in a real execution environment | 04-30-2009 |
20090125919 | On-demand loading of types of software code of a program executing on a computing device - A first computing device receives (over a network) from at least a second computing device a container that includes information relating to types of software code that are potentially invoked by a program executing on the first computing device. A determination is made according to an on-demand basis, during execution of the program, whether a particular type of software code is to be loaded from the at least second computing device to the first computing device. | 05-14-2009 |
20090132998 | DEBUGGING MULTI-EXECUTION ENVIRONMENT APPLICATIONS - A framework is provided that allows for debugging of applications/systems that execute in multiple execution environments. Instead of using the native application programming interface to interact with an execution environment, an alternative implementation of at least some of the application programming interface of the native execution environment is employed to facilitate debugging in a disparate execution environment. | 05-21-2009 |
20090144229 | STATIC QUERY OPTIMIZATION FOR LINQ - Systems and methods that optimize query translations at compile time in LINQ languages. An optimization component optimizes algebraic trees and rewrites an expression composed from sequence operators into a more efficient expression(s). A compiler associated with the optimization component can receive syntax (e.g., query comprehensions, query expressions) to turn into standard sequence operators that can operate on arbitrary collections. The compiler can then perform transformations on the algebraic trees, such as push filter conditions upwards or downwards and/or to combine filter conditions. | 06-04-2009 |
20090199159 | DECLARATIVE EXECUTION CONTEXT SPLITTING - Various technologies and techniques are disclosed for enabling code to be executed on one or more execution contexts based upon declarative annotations contained in the code or other locations. An annotation associated with a region of code is located. The annotation specifies information about an execution context where the region of code should be executed. A caller proxy is generated that is responsible for calling a callee adapter to execute the region of code. The callee adapter is generated that is responsible for receiving a call from the caller proxy and for dispatching a call to the region of code at the execution context. At runtime, the caller proxy receives a request to call the region of code and sends an execution request to the callee adapter. The callee adapter receives the execution request and dispatches a call to an executable version of the region of code. | 08-06-2009 |
20090248624 | FUNCTIONAL UPDATES FOR TREE PROCESSING - 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. | 10-01-2009 |
20090249282 | CROSS PLATFORM COMPOSITIONAL WIDGETS - Mechanisms are afforded for supporting cross platform widgets. A generic widget can be converted into a specialized widget of a corresponding platform. Dually, a specialized widget can be generalized to a generic widget for subsequent deployment on the same or different host. Furthermore, support is provided for compositional widgets across platforms. | 10-01-2009 |
20090249310 | AUTOMATIC CODE TRANSFORMATION WITH STATE TRANSFORMER MONADS - Stateful computations are transformed into stateless computations automatically to facilitate scalability. Programmers can write code in a traditional imperative stateful style, which is subsequently transformed automatically into a stateless, state transformer monadic style. After the transformation, state is passed as an additional argument in a call and returns as a new state as an additional result. | 10-01-2009 |
20090249489 | SECURITY BY CONSTRUCTION FOR WEB APPLICATIONS - Secure distributed Web applications are produced by default upon construction. Mechanisms are provided to address distributed application vulnerabilities (e.g., cross-site scripting, cross-site request forgery, replay attacks . . . automatically. These mechanisms are provided in conjunction with a tier-splitting component that breaks up an application for execution across multiple contexts or tiers. As a result, any application that is tier split is protected from security vulnerabilities by default without any intervention on the part of a developer. | 10-01-2009 |
20090265719 | APPLICATION MACRO RECORDING UTILIZING METHOD INTERCEPTION - Method interception is utilized to generate macros. A recorder is injected within application code. The recorder intercepts a call to a method, captures information, and calls the original method. A macro can be generated subsequently as a function of the captured information. In one instance, macros can be utilized to test the application code. Additionally, information capture and ultimately macro generation can be combined with a tier splitting mechanism. | 10-22-2009 |
20090271382 | EXPRESSIVE GROUPING FOR LANGUAGE INTEGRATED QUERIES - Standard group operators afford expressive grouping across collections of various types for employment by a number of programming languages. The operators can leverage positional information to facilitate grouping of sequential/ordered input data. Groups can also include more than one input element. Additionally or alternatively, the operators can enable multi-level grouping such as nested or hierarchical grouping. In accordance with one aspect, the group operators can be employed in conjunction with language-integrated queries. | 10-29-2009 |
20090276791 | TECHNIQUES FOR FACILITATING SERVER CALLBACKS - Various technologies and techniques are disclosed for facilitating server callbacks. A request is received from a client computer to monitor for one or more events for the client computer. The server computer monitors for the one or more events and detects one or more occurrences of the events. Information regarding the one or more occurrences of the events is added to an event queue. On a later communication with the client computer, the event queue is sent as part of a response so the occurrences of the events can be handled on the client computer by one or more event handlers on the client computer. Techniques are also described for enabling server callbacks in execution context splitting scenarios where a region of code has been split across different execution contexts. | 11-05-2009 |
20090276795 | VIRTUAL AUTOMATA - Computer-based machines can be modeled after a virtual automaton. The virtual automaton defines processes that are not bound statically to particular behavior but rather perform a lookup at runtime to bind behavior to a specific process mechanism. In accordance with one aspect, binding can be dependent upon runtime context information such as object type. Instances of virtual automaton are provided in the context of graph processing including serialization of object graphs and scanning/parsing, among others. | 11-05-2009 |
20090328012 | COMPILER IN A MANAGED APPLICATION CONTEXT - A batch compiler is employed to enable compilation of code provided at runtime. A managed application receives code during execution and invokes the compiler to transform the code to enable it to execute within the context of the receiving application. Among other things, employment of a batch compiler preserves investments made to such compilers while also opening up new scenarios in application scripting and/or hosting that are otherwise unavailable. | 12-31-2009 |
20090328013 | COMPONENTIZATION OF COMPILER FUNCTIONALITY - Compiler functionality is componentized to enable use across different contexts. Conventionally tightly coupled functionality is decoupled and an interface afforded to facilitate interaction with compiler components/subcomponents in various scenarios. In one instance, compiler components can be employed across compile time and runtime. Compile time functionality can be employed at runtime and runtime functionality utilized at compile time thereby blurring the line between time dimensions. | 12-31-2009 |
20090328016 | GENERALIZED EXPRESSION TREES - Expression tree versatility and applicability are enhanced to facilitate programming across various program languages and execution contexts. An expression tree can represent programmatic code as data in a representation common to multiple process mechanisms. As a result, entire programs or portions thereof can be captured and processed by a numerous common language components. Further, language specific concepts can be reduced to the common representation to enable language independent employment. | 12-31-2009 |
20100010801 | CONFLICT RESOLUTION AND ERROR RECOVERY STRATEGIES - A plethora of strategies is afforded to facilitate conflict resolution and error recovery with respect to parsing, among other things. Grammar authors can select amongst a range of strategies or options on a case-by-case basis to address conflicts, ambiguities, errors, and the like. The strategies can be either static or dynamic. In one instance, code external to a parsing system can be invoked to resolve conflicts or recover from errors, and further enable change of strategy without requiring modification of the parser. Interaction between the parsing system and the external code can also be formalized to ensure general type safety of the system. | 01-14-2010 |
20100023798 | ERROR RECOVERY AND DIAGNOSIS FOR PUSHDOWN AUTOMATA - Error recovery and diagnosis is afforded for pushdown automata. Upon detection of an error, a recovery strategy is selected and dispatched to recover from the error to place an automaton in an error free state to enable continued processing. In one instance, recovery strategies can be specified and matched with respect to automaton configuration. Errors can be diagnosed as a function of the difference between a first error configuration and a second recovered configuration. | 01-28-2010 |
20100023924 | NON-CONSTANT DATA ENCODING FOR TABLE-DRIVEN SYSTEMS - Parse tables or like representations are augmented with extension points to enable call out to arbitrary code. Such parse tables can be automatically generated from a specification including fixed information along with information about extensibility points provided. The extensibility points enable incorporation of dynamic data into a fixed parse table. In one instance, this allows a parser to determine if a character is acceptable at the time of execution rather than when the parse table was defined. | 01-28-2010 |
20100024030 | RESTARTABLE TRANSFORMATION AUTOMATON - Data transformation is lazily performed to facilitate reduced memory footprint, among other things. Rather than constituting an entire data structure, information is saved to enable iterative construction the structure. Moreover, an interface is afforded that appears to operate over a fully resolved structure but which is implemented on top of a restartable transformation mechanism that computes values in response to requests. These computed values could also be released based on one or more configurable policies. | 01-28-2010 |
20100037212 | IMMUTABLE PARSING - Immutable structures are employed to effect immutable parsing. In particular, an immutable parsing configuration, comprising a stack and lookahead buffer, is utilized by a parser to perform lexical and syntactical analysis of an input stream and optionally output an immutable parse tree or the like. Performance with respect to the immutable structures can be optimized utilizing sharing and lazy computation. In turn, immutability benefits are afforded with respect to parsing including safe sharing amongst services and/or across multiple threads as well as history preservation, among other things. | 02-11-2010 |
20100037213 | GRAMMAR-BASED GENERATION OF TYPES AND EXTENSIONS - Parsing functionality is automatically generated. In particular, abstract syntax tree types and/or other programmatic constructs are created automatically from a grammar specification in a manner that resembles hand-written code. An abstract syntax tree can subsequently be constructed as a function of the generated types. Further, a plurality of supporting functionality can be generated to consume or produce abstract syntax tree types, among other things. | 02-11-2010 |
20100042982 | OPTIMIZATION OF IMPERATIVE IMPLEMENTATION OF COMPOSITIONAL CONTENT - Compositional program content is compiled to statements of an imperative application interface in manners that optimize execution and/or resource utilization, among other things. In one instance, a constructor is employed in a manner that obviates a need for extensive memory allocation and parameter copying. Names and namespaces are also cached to avoid expensive table lookup, and redundant namespace declarations are removed and/or moved statically and/or dynamically. | 02-18-2010 |
20100057822 | INVERSE TRANSFORMATION LOADING - An inverse transformation and/or identification thereof is transmitted to a receiver to enable interpretation of transformed data. Rather than requiring installation of a transform on a sender and an inverse transform on a receiver prior to communication, an appropriate inverse transformation can be provided to and executed by a receiving component as needed. In accordance with one aspect, a transformation and associated inverse are selected dynamically as a function of context to minimize or maximize some parameter, for instance. | 03-04-2010 |
20100058285 | COMPOSITIONAL VIEW OF IMPERATIVE OBJECT MODEL - A compositional or alternate object model is employed over an imperative object model to facilitate inspection and construction of imperative structures in a user-friendly manner. Transformations between compositional and imperative models and vice versa can be specified to provide a bridge between differing computing worlds. Moreover, various architectures and/or design patterns can be employed to effect transformation in different ways. | 03-04-2010 |
20100082751 | USER PERCEPTION OF ELECTRONIC MESSAGING - Determining user use context for electronic messaging and disseminating a subset of the user use context to recipients and/or senders of such electronic message is disclosed herein. By way of example, the user use context can be based on a general context of recipients, such as speed with which a message is disseminated or consumed, number of child messages spawned, rate at which such messages are spawned, and so on. Additionally, user use context can also be based on individual context, by comparing individual interaction to a message (e.g., time to read, time to delete, number of child messages, etc.), with a baseline usage context determined for the individual. The context can be disseminated to recipients of the message or to the sender, to provide an overview of perception of the electronic message. | 04-01-2010 |
20100094939 | TRANSIENT NETWORKS - 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. | 04-15-2010 |
20100106767 | AUTOMATICALLY SECURING DISTRIBUTED APPLICATIONS - 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. | 04-29-2010 |
20100131556 | UNIFIED EVENT PROGRAMMING AND QUERIES - 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. | 05-27-2010 |
20100131743 | LAZY AND STATELESS EVENTS - 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. | 05-27-2010 |
20100131745 | EXCEPTIONAL EVENTS - 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. | 05-27-2010 |
20100131921 | EXPOSING ASYNCHRONOUS MECHANISMS AS FIRST-CLASS EVENTS - 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. | 05-27-2010 |
20100156900 | IMPLIED ANALYTICAL REASONING AND COMPUTATION - 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). | 06-24-2010 |
20100162218 | RELAXED AND EXTENDED DELEGATES - 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. | 06-24-2010 |
20100175048 | ARCHITECTURE THAT EXTENDS TYPES USING EXTENSION METHODS - 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. | 07-08-2010 |
20100217776 | ANONYMOUS TYPES FOR STATICALLY TYPED QUERIES - 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. | 08-26-2010 |
20100218173 | IMPLICIT LINE CONTINUATION - 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. | 08-26-2010 |
20100223212 | TASK-RELATED ELECTRONIC COACHING - Providing for task-related electronic feedback based on user interaction with a communication network is described herein. By way of example, user interactions the network or a network interface can be monitored to identify user activities performed in conjunction with a task. A rating for performance of the task can be obtained via comparison of user activities with benchmark performance activities. Based on the rating and user-benchmark comparison, inefficiencies can be identified, along with corrective actions for such activities. The corrective actions can then be output to coach the user on techniques for improving performance of the task. Accordingly, by employing corrective feedback based on monitored user activity, personal training can be automated, potentially reducing time and cost of such training. | 09-02-2010 |
20100223341 | ELECTRONIC MESSAGING TAILORED TO USER INTEREST - Providing for electronic messaging tailored to contexts or interests of one or more participants of electronic communication is described herein. By way of example, a message can be analyzed during or after compilation to determine a context of the message. Message participants can be identified and a context for such participants determined. Based on the message context or participant context, the message can be modified to be consistent with interests, preferences or other context of one or more participants. In some aspects, the message can be modified upon receipt by a recipient's communication device or messaging application. According to other aspects, the message can be modified at compilation, or transmission. In accordance with still other aspects, message modifications can be output as suggested feedback to improve receptivity or utility of a message. | 09-02-2010 |
20100223581 | VISUALIZATION OF PARTICIPANT RELATIONSHIPS AND SENTIMENT FOR ELECTRONIC MESSAGING - Providing for graphical visualization of contextual information pertinent to electronic messaging is described herein. By way of example, contextual network usage information or messaging disposition can be determined for a set of participants to electronic communication. The contextual information is compiled into categories and organized at least as a function of category. The compiled data can be transformed into a visualization of user disposition or context and output to a user device as a multi-dimensional graphical rendering. By rendering contextual data graphically, the rich and diverse information available from usage histories, current user context and user dispositions can be output and consumed rapidly and efficiently, resulting in productive electronic interaction. | 09-02-2010 |
20110072413 | EMBEDDING EXPRESSIONS IN XML LITERALS - An architecture that that extends conventional computer programming languages that compile into an instance of an extensible markup language (XML) document object model (DOM) to provide support for XML literals in the underlying programming language. This architecture facilitates a convenient short cut by replacing the complex explicit construction required by conventional systems to create an instance of a DOM with a concise XML literal for which conventional compilers can translate into the appropriate code. The architecture allows these XML literals to be embedded with expressions, statement blocks or namespaces to further enrich the power and versatility. In accordance therewith, context information describing the position and data types that an XML DOM can accept can be provided to the programmer via, for example, an integrated development environment. Additionally, the architecture supports escaping XML identifiers, a reification mechanism, and a conversion mechanism to convert between collections and singletons. | 03-24-2011 |
20110107392 | MANAGEMENT OF OBSERVABLE COLLECTIONS OF VALUES - Architecture that a mathematical duality established herein between an asynchronous observable design pattern and a synchronous iterator design pattern. This provides a mechanism for processing multiple observable collection and asynchronous values associated with those collections, including situations where a single observable collection is directed to multiple subscribers or multiple observable collections are directed to a single subscriber. Operators are presented that facilitate multi-collection processing based on this proven duality. As a result of this duality concurrent asynchronous and event-driven programs can be elegantly formulated. Consequently, asynchronous and event-based programming can now be unified into single conceptual framework, based on sound mathematical principles such as monads and duality. | 05-05-2011 |
20110138403 | PUSH-BASED APPLICATION PROGRAM INTERFACE BASED ON DUALS OF A PULL-BASED APPLICATION PROGRAM INTERFACE - Methods and devices are provided for defining push-based standard sequence operators based on respective duals of corresponding pull-based standard sequence operators. A push-based application program interface (API) may be defined based on mathematical duals of a corresponding pull-based API. The push-based API may include a library of routines, which further may include push-based standard sequence operators defined based on deriving mathematical duals of corresponding pull-based standard sequence operators. A protocol for processing a push-based collection may be defined as a mathematical dual of a protocol for processing a pull-based collection. In various embodiments, mathematical duality with respect to synchronous, pull-based, collections may be exploited to define operators for processing asynchronous push-based collections. | 06-09-2011 |
20110145734 | Processing Computer Implemented Action - A method for processing a computer action using a processor. The method includes receiving a first request to perform a first computer action, performing the first computer action and producing a first class representation of the first computer action. | 06-16-2011 |
20110167248 | EFFICIENT RESUMPTION OF CO-ROUTINES ON A LINEAR STACK - Unsuspended co-routines are handled by the machine call stack mechanism in which the stack grows and shrinks as recursive calls are made and returned from. When a co-routine is suspended, however, additional call stack processing is performed. A suspension message is issued, and the entire resume-able part of the call stack is removed, and is copied to the heap. A frame that returns control to a driver method (a resumer) is copied to the call stack so that resumption of the co-routine does not recursively reactivate the whole call stack. Instead the resumer reactivates only the topmost or most current frame called the leaf frame. When a co-routine is suspended, it does not return to its caller, but instead returns to the resumer that has reactivated it. | 07-07-2011 |
20110173620 | Execution Context Control - A system and method for controlling the execution of notifications in a computer system with multiple notification contexts. A RunOn operator enables context hopping between notification contexts. Push-based stream operators optionally perform error checking to determine if notifications combined into a push-based stream share a common notification context. Context boxes group together notification creators and associate their notifications with a common scheduler and notification context. Operators employ a composition architecture, in which they receive one or more push-based streams and produce a transformed push-based stream that may be further operated upon. Components may be used in combinations to implement various policies, including a strict policy in which all notifications are scheduled in a common execution context, a permissive policy that provides programming flexibility, and a hybrid policy that combines flexibility with error checking. | 07-14-2011 |
20110173621 | PUSH-BASED OPERATORS FOR PROCESSING OF PUSH-BASED NOTIFICATIONS - A library of operators is provided for performing operations on push-based streams. The library may be implemented in a computing device. The library may be stored on a tangible machine-readable medium and may include instructions to be executed by one or more processors of a computing device. The library of operators may include groups of operators for performing various types of operations regarding push-based streams. The groups of operators may include, but not be limited to, standard sequence operators, other sequence operators, time operators, push-based operators, asynchronous operators, exception operators, functional operators, context operators, and event-specific operators. | 07-14-2011 |
20110191784 | PROCESSING OBSERVABLE EVENTS USING JOIN PATTERNS - Methods, systems, and computer-readable media of processing observable events using join patterns are disclosed. A particular method includes receiving a first notification indicating an occurrence of a first observable event and a second notification indicating an occurrence of a second observable event. The method also includes determining that the first and second notifications satisfy a join pattern. The method may further include taking one or more actions in response to determining that the join pattern has been satisfied. | 08-04-2011 |
20110202909 | TIER SPLITTING FOR OCCASIONALLY CONNECTED DISTRIBUTED APPLICATIONS - Distributed programming is aided by tier splitting single-tier applications into multi-tier applications. Computations and persistent data are split across tiers to generate offlineable or occasionally connected distributed applications. More specifically, computations are divided amongst tiers while preserving the semantics of a single-tier application, and upstream-tier resident data and changes thereto are replicated downstream to facilitate offline work. | 08-18-2011 |
20110225565 | OPTIMAL INCREMENTAL WORKFLOW EXECUTION ALLOWING META-PROGRAMMING - A workflow is described and subsequently constructed by a general-purpose program. Among other things, such construction enables meta-programming to be employed. Further, workflow item and task dependencies can be explicitly expressed in the workflow and utilized to, among other things, optimize workflow execution for one or more factors. For instance, dependency information can be employed with respect to scheduling concurrent execution of tasks as well as to confine re-execution, upon workflow or item changes, to tasks affected by the changes. In addition, messages pertaining to workflow processing can be typed to facilitate logging in a structured and easily comprehensible manner. | 09-15-2011 |
20110239229 | PREDICATIVE AND PERSISTENT EVENT STREAMS - An event driven application may predict a future event and spawn an event stream from the predicted event. The spawned event stream may be performed as a predicted operation until the prediction is confirmed to be correct or incorrect. The predicted operation may generate results that may be present when the prediction is confirmed. In some cases, the results may be used prior to the predicted event, while in other cases, the results may be cached until the prediction is confirmed. In some cases, the predicted operation may be merged with an actual event stream when the predicted event occurs. The prediction mechanism may enhance performance, enable operations that would otherwise be difficult, and may save battery life or energy in some devices. | 09-29-2011 |
20110246962 | STATE MACHINE EXPRESSIONS IN DATABASE OPERATORS - A state machine may be represented using event-driven objects in a database query language. A bind operator from a database query language may be used as a state transition function, where the transition function has side effects defining the state. The objects may be manipulated with event driven expressions and operators and perform what would otherwise be complex operations with simple state machines. | 10-06-2011 |
20110246973 | COMPILER SUPPORTING PROGRAMS AS DATA OBJECTS - A compiler supporting a language in which selected semantic objects are represented as data objects. The data objects may be used in multiple ways to expand the capabilities of the programming language. Data objects may be passed to applications and used to create executable instructions for that application. In this way, instructions written in the native language of the compiler may be used to control applications that accept programs in a language inconsistent with the native language of the compiler. The syntax checking and variable binding capabilities of the compiler may be used for those instructions that will be executed by an application separate from the object code generated by the compiler. The semantic objects represented as data objects may be selected based on express operations included in the source code or may be based on implicit type conversion. | 10-06-2011 |
20110265070 | RESUMABLE METHODS - APIs are provided, that are external to a programming language but that provide functionality that can be plugged into a language compiler. The provided APIs tailor functionality associated with asynchronous programming, iterators or writing symmetric co-routines using a generalized pattern-based approach. Several types of resumable methods are provided in the APIs which can be applied to method bodies written in traditional program code. Syntactically distinguishable control points in method bodies written in traditional program code invoke transformation of the code by the compiler using the external APIs. The transformed code enables the pausing and resumption of the code sandwiched between control points in the transformed code. The source code contained within a method having control points in it is transformed so that code within the method can be executed in discrete parts, each part starting and ending at a control point in the transformed code. | 10-27-2011 |
20110276977 | DISTRIBUTED WORKFLOW EXECUTION - A workflow is designated for execution across a plurality of autonomous computational entities automatically. Among other things, the cost of computation is balanced with the cost of communication among computational entities to reduce total execution time of a workflow. In other words, a balance is struck between grouping tasks for execution on a single computational entity and segmenting tasks for execution across multiple computational entities. | 11-10-2011 |
20120047495 | EXECUTION ENVIRONMENT SUPPORT FOR REACTIVE PROGRAMMING - An execution environment is created or extended to include support for coroutines to facilitate reactive programming. Utilizing functionality provided by an execution environment, such as a virtual machine, additional operations are derived to enable creation, invocation, and suspension of coroutines. | 02-23-2012 |
20120072411 | DATA REPRESENTATION FOR PUSH-BASED QUERIES - A query over one or more push-based data sources is transformed into a data representation of the query. The data representation can subsequently be analyzed, optimized, and remoted, among other things. For example, the data representation can be utilized to generate code for an out-of-process execution engine. Additionally, the data representation can be employed with respect to conversions to and from various types and representations of data. | 03-22-2012 |
20120072442 | MONADIC TYPE PRESERVATION FOR QUERY OPERATORS - Monadic types are preserved for query operators to further query operator compositionality utilizing operators defined over a monad. Query operators that are defined over a monad and are suited to return non-monadic types are constructed or altered to return a monadic type. For instance, aggregate query operators defined over a local or remote sequence monad can be generated that return a monadic type. | 03-22-2012 |
20120078878 | OPTIMIZED LAZY QUERY OPERATORS - Query operators such as those that perform grouping functionality can be implemented to execute lazily rather than eagerly. For instance, one or more groups can be created and/or populated lazily with one or more elements from a source sequence in response to a request for a group or element of a group. Furthermore, lazy execution can be optimized as a function of context surrounding a query, among other things. | 03-29-2012 |
20120078974 | DATA MODEL DUALIZATION - A data model can be generated by dualizing another data model. In other words, a first data model can be transformed into a second data model, wherein the second data model is a mathematical dual of the first data model. For example, a non-relational data model can be generated by dualizing a relational data model. | 03-29-2012 |
20120079464 | QUERY CONSTRAINT ENCODING WITH TYPE-BASED STATE MACHINE - A query specified in a source programming language can be analyzed as a function of a type-based state machine that encodes query constraints of a target programming language. The type-based state machine can encode such constraints as types representing states and methods representing transitions between states or types. | 03-29-2012 |
20120084749 | PROGRAMMING LANGUAGE SUPPORT FOR REACTIVE PROGRAMMING - Program language support is provided to facilitate reactive programming. Code can be provided that initiates conversion between a first-class pattern and a second-class pattern, wherein the patterns operate with respect to push-based data. Support is also provided for producing and consuming push-based data in accordance with an iterator pattern, for example. | 04-05-2012 |
20120095750 | PARSING OBSERVABLE COLLECTIONS - Parsing technology is applied to observable collections. More specifically, a parser, such as combinator parser, can be employed to perform syntactic analysis over one or more observable collections. Further, multiple observable collections can be combined into a single collection and time can be captured by annotating collection items or generating time items. | 04-19-2012 |
20120096435 | CAPABILITY-BASED APPLICATION RECOMMENDATION - Capabilities associated with a capability-based security model are utilized as a basis for discriminating between software applications. More specifically, software applications can be identified as a function of capabilities. A comparison can be made between software application capabilities and capabilities of interest to identify matches. Subsequently, users can be notified of any matching software applications. | 04-19-2012 |
20120109935 | OBJECT MODEL TO KEY-VALUE DATA MODEL MAPPING - Access to data is facilitated by mapping between an object model and a key-value data model that supports a notion of worlds. The object model can be expressed in a programming language that supports language-integrated queries. One or more query operators comprising a language-integrated query can be specified and executed with respect to a key-value world. | 05-03-2012 |
20120110004 | HOMOMORPHISM LEMMA FOR EFFICIENTLY QUERYING DATABASES - A representation of a language-integrated query can be generated based upon a homomorphism characteristic of the query. The representation can be utilized to enable efficient execution of the query on a key-value store, for example. More specifically, the query can be transformed into a representation utilizing language integrated query operators that enables parallel execution. | 05-03-2012 |
20120110428 | SPREADSHEET MODEL FOR DISTRIBUTED COMPUTATIONS - A spreadsheet model is employed to facilitate distributed computations. Spreadsheets and cells are generalized to correspond to arbitrary data sources that can be remote from each other, among other things. Functions can be specified with respect to these arbitrary data sources to produce combinations of data or mashups, for example, wherein changes initiate re-computation with respect to dependent data sources. | 05-03-2012 |
20120117554 | ON-DEMAND LOADING OF TYPES OF SOFTWARE CODE OF A PROGRAM EXECUTING ON A COMPUTING DEVICE - A first computing device receives (over a network) from at least a second computing device a container that includes information relating to types of software code that are potentially invoked by a program executing on the first computing device. A determination is made according to an on-demand basis, during execution of the program, whether a particular type of software code is to be loaded from the at least second computing device to the first computing device. | 05-10-2012 |
20120131546 | CODE DEPLOYMENT ASSISTANCE - Computer programming is aided by way of automatic code generation, and more specifically generation of deployment code automatically. An application can be analyzed and deployment code, including installation, maintenance (e.g., update/upgrade), and removal (e.g., un-install) code, can be generated as a function of the analysis as well as a particular execution environment. | 05-24-2012 |
20120144054 | MIXING SYNCHRONOUS AND ASYNCHRONOUS DATA STREAMS - A queue can store streams of data acquired from servers asynchronously based upon received data requests and subsequent subscription with respect to one or more data sources/servers. The queue can be managed for subsequent synchronous or asynchronous release of received streams of data, for example. | 06-07-2012 |
20120150514 | REACTIVE COINCIDENCE - An outer event stream can be modeled to represent duration for an event with an inner event stream. The inner event stream can be generated to represent duration of at least one event from the outer event stream. By modeling the outer event stream to include duration, coincidence between two or more events can be determined. More specifically, the modeling of the outer event stream enables use of operators to identify coincidence between events from event streams. | 06-14-2012 |
20120150913 | MULTIDIMENSIONAL DATA-CENTRIC SERVICE PROTOCOL - Data acquisition is facilitated by way of an intermediate representation of a query expression. The intermediate representation can be generated and subsequently transmitted to, and employed by, a plurality of execution environments with respect to query execution. More particularly, the intermediate representation can be transformed into a locally executable query expression. Furthermore, numerous factors can shape the created and transmitted intermediate representation. | 06-14-2012 |
20120151187 | INSTRUCTION OPTIMIZATION - Programs can be optimized at runtime prior to execution to enhance performance. Program instructions/operations designated for execution can be recorded and subsequently optimized at runtime prior to execution, for instance by performing transformations on the instructions. For example, such optimization can remove, reorder, and/or combine instructions, among other things. | 06-14-2012 |
20120158763 | BULK OPERATIONS - Bulk operations including create, update, and delete operations are supported within the context of language-integrated queries. Such bulk operations can be implemented as distinct operations. Other operations, including query operators defining a collection of data over which the bulk operations can execute, can be restricted as a function of a specific bulk operation. | 06-21-2012 |
20120173592 | COMPOSITE NESTED STREAMS - 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. | 07-05-2012 |
20120323984 | LANGUAGE INTEGRATED QUERY OVER VECTOR SPACES - 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. | 12-20-2012 |
20130091295 | PUBLISH/SUBSCRIBE SYSTEM INTEROPERABILITY - 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. | 04-11-2013 |
20130097580 | ASYNCHRONOUS PROGRAMMING MODEL MAPPING - 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. | 04-18-2013 |
20130103715 | MONADIC EVALUATION OF INJECTED QUERY COMPOSITIONS - 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. | 04-25-2013 |
20130104107 | DATA FLOW VISUALIZATION AND DEBUGGING - 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. | 04-25-2013 |
20130110853 | SQL CONSTRUCTS PORTED TO NON-SQL DOMAINS | 05-02-2013 |
20130110876 | PERMISSION BASED QUERY PROCESSING | 05-02-2013 |
20130117257 | QUERY RESULT ESTIMATION - Techniques for efficiently performing queries are provided. A search component can receive a request for information based on data, and a management component can determine a degree of accuracy requested for the information. In turn, the search component can render the information based on the degree of accuracy requested. In an aspect, the search generates a query configured to determine the first information, and the management component instructs the search component to perform the query to a level of completion less than full completion when the degree of accuracy requested is below a predetermined threshold to cause the search component to render an estimation of the first information. In another aspect, a tracking component can track information associated with multiple query requests and an analysis determine and employ a related aspect of the tracked information to a new query request to determine an answer for a the new query request. | 05-09-2013 |
20130117272 | SYSTEMS AND METHODS FOR HANDLING ATTRIBUTES AND INTERVALS OF BIG DATA - Data management techniques are provided for handling of big data. A data management process can account for attributes of data by analyzing or interpreting the data, assigning intervals to the attributes based on the data, and effectuating policies, based on the attributes and intervals, that facilitate data management. In addition, the data management process can determine relations among data in a data collection and generate and store approximate results concerning the data based on the attributes, intervals, and the policies. | 05-09-2013 |
20130117288 | DYNAMICALLY TYPED QUERY EXPRESSIONS - A dynamic call on dynamic data can be transformed into a dynamic call on a structure representing dynamic data. Specifically, a dynamic query with a code object representation that includes an untyped parameter can be transformed into a dynamic query with a function call with a dynamic meta-object. The function call with the dynamic meta-object tracks operation(s) that correspond to the code object representation that includes an untyped parameter in order to build a structure representing such code object representation. At runtime, the dynamic query is built and the structure representing the code object representation is rebuilt so as to enable a dynamic query with a code object representation that references untyped data. | 05-09-2013 |
20130117326 | EXTERNAL SERIALIZATION AND DESERIALIZATION - An object graph can be transformed from a first form to a second form based on metadata discovered about objects of the object graph external to a corresponding object model. In one instance, transformation can correspond to serialization and deserialization. | 05-09-2013 |
20130117736 | REACTIVE EXPRESSION GENERATION AND OPTIMIZATION - Reactive programming is facilitated. Reactive expressions can be generated automatically from non-reactive expressions or in other words standard expressions. Additionally or alternatively, reactive expressions can be optimized in a number of different ways to minimize computational work. | 05-09-2013 |
20130132333 | MULTIDIMENSIONAL GROUPING OPERATORS - A multidimensional object, such as a language-integrated query (LINQ) object, can be generated based upon a grouping set operator and zero or more key selectors. The object can be utilized to query over a non-relational data source. The object can include a sequence of functions corresponding to each grouping related to the grouping set operator in order to provide multidimensional grouping representation. Furthermore, the object includes nested structures for optimized execution of the grouping set operator. | 05-23-2013 |
20130132962 | SCHEDULER COMBINATORS - Scheduler combinators facilitate scheduling. One or more combinators, or operators, can be applied to an existing scheduler to compose a new scheduler or decompose an existing scheduler into multiple facets. | 05-23-2013 |
20130159228 | DYNAMIC USER EXPERIENCE ADAPTATION AND SERVICES PROVISIONING - The subject disclosure generally relates to dynamic user experience adaptation and services provisioning. A user experience component can provide a user experience (UX) to a user. The UX can include, but is not limited to, an operating system, an application (e.g., word processor, electronic mail, computer aided drafting, video game, etc.), a user interface, and so forth. A monitoring component can monitor feedback generated in association with interaction with the user experience by the user. An update component can analyze the feedback, and update a user model associated with the user based at least in part on the analysis, and an adaptation component can modify the user experience based at least in part the user model. | 06-20-2013 |
20130159500 | DISCOVERY AND MINING OF PERFORMANCE INFORMATION OF A DEVICE FOR ANTICIPATORILY SENDING UPDATES TO THE DEVICE - The subject disclosure relates to techniques for monitoring contextual and performance information of a device for anticipatorily sending update information to the device. An interface component can receive, from the client, contextual information indicating an operating environment of the client and performance information that is associated with one or more operations being performed by the client based on the operating environment, and send, based on correlation information, update information to the client. Further, a service component can to infer a relationship between the contextual information and the performance information to obtain the correlation information. In other embodiments, a client can populate a cache with portion(s) of the contextual information to obtain cached information, and send at least a portion of the cached information to a system including one or more aspects of the service component. | 06-20-2013 |
20130159969 | DIGITAL SIGNAL PROCESSING WITH LANGUAGE INTEGRATED MONADS - Digital signal processing is facilitated utilizing monads. In other words, a digital signal can be processed as a function of at least one monadic operation over the digital signal. Monadic operations can also be integrated into a general-purpose programming language optionally in a declarative syntax to further facilitate programming with respect to digital signals. | 06-20-2013 |
20130268531 | Finding Data in Connected Corpuses Using Examples - In one embodiment, datasets are stored in a catalog. The datasets are enriched by establishing relationships among the domains in different datasets. A user searches for relevant datasets by providing examples of the domains of interest. The system identifies datasets corresponding to the user-provided examples. The system them identifies connected subsets of the datasets that are directly linked or indirectly linked through other domains. The user provides known relationship examples to filter the connected subsets and to identify the connected subsets that are most relevant to the user's query. The selected connected subsets may be further analyzed by business intelligence/analytics to create pivot tables or to process the data. | 10-10-2013 |
20130268552 | Brokered Exchange of Private Data - A data broker observes datasets that are opened or created by a user. The data broker looks for related datasets in a data catalog. If a related dataset is found, the data broker asks the user if they want to access the related dataset. If the user is interested, then the data broker asks the data owner if they are willing to share access to the related dataset with the user. The data owner may deny access, allow access, or request the user's identity. If the user does not want to provide his or her identity, then access to the related dataset is denied. If the user does provide his or her identity, then the data owner determines whether or not to share the data with that user. Once the owner approves sharing the related dataset, then the dataset or a link to the dataset is sent to the user. | 10-10-2013 |
20130275434 | DEVELOPING IMPLICIT METADATA FOR DATA STORES - A system enables metadata to be gathered about a data store beginning from the creation and generation of the data store, through subsequent use of the data store. This metadata can include keywords related to the data store and data appearing within the data store. Thus, keywords and other metadata can be generated without owner/creator intervention, with enough semantic meaning to make a discovery process associated with the data store much easier and efficient. Usage of or communication regarding a data store are monitored and keywords are extracted from the usage or communication. The keywords are then written to otherwise associated with metadata of the data store. During searching, keywords in the metadata are made available to be used to attempt to match query terms entered by a searcher. | 10-17-2013 |
20130290987 | TYPE INFERENCE AND TYPE-DIRECTED LATE BINDING - Systems and methods that enhance and balance a late binding and an early binding in a programming language, via supplying an option component to opt-in (or opt-out) late binding, and wherein a late binding is triggered based on a static type for the variable (e.g., object or a type/string.) Additionally, the variable is enabled to have different static types at different regions (e.g., a program fragment) of the programming language. | 10-31-2013 |
20140067871 | DELEGATION OF EXPRESSION TREE EVALUATION - Evaluating an expression tree. A method includes, at a first domain, accessing an expression tree. The expression tree comprises a plurality of nested expressions. The plurality of nested expressions spans a plurality of domains. The expressions in the expression tree are expressed in a common format in spite of the different expressions of the expression tree being intended to be evaluated by different domains. At the first domain, the method includes evaluating one or more references to local variables included in the plurality of nested expressions. The method further includes determining that one or more expressions in the plurality of expressions are to be evaluated by a different domain. The method further includes expanding the one or more expressions in the plurality of expressions to be evaluated by different domains to allow the one or more expressions to be evaluated by the different domain. | 03-06-2014 |
20140082174 | Serialization of Run-Time State - The claimed subject matter provides a system and/or a method that facilitates re-locating a web application associated with a network service utilizing a portion of serialized data. The network service can be any collection of resources that are maintained by a party (e.g., third-party, off-site, etc.) and accessible by an identified user over a network (e.g., WAN, Internet, etc.). An interface component can receive a portion of serialized data with transparent structure related to an application specification. A hydrate component can create a web application independent of a network service based at least in part upon the serialized data, the web application has state within the network service. | 03-20-2014 |
20140165037 | REUSABLE APPLICATION USER EXPERIENCE - Reusable user experience is provided by way of styleable applications. An application can be segmented into a content portion and a style portion, if not originally designed that way. Subsequently, alternate style code can be injected to provide a style to an application lacking style or replace a style with a different style. Styles can be extracted from other applications or acquired from an online marketplace, for instance. | 06-12-2014 |
20140282879 | Automatically Securing Distributed Applications - 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. | 09-18-2014 |
20140289715 | IMMUTABLE PARSING - Immutable structures are employed to effect immutable parsing. In particular, a parsing configuration, comprising a stack and lookahead buffer, is utilized by a parser to perform lexical and syntactical analysis of an input stream and optionally output an immutable parse tree or the like, wherein at least one of the stack and buffer is immutable. Performance with respect to the immutable structures can be optimized utilizing sharing and lazy computation. In turn, immutability benefits are afforded with respect to parsing including safe sharing amongst services and/or across multiple threads as well as history preservation, among other things. | 09-25-2014 |
20140344344 | PRE-FETCHING IN DISTRIBUTED COMPUTING ENVIRONMENTS - Client-side performance is optimized through server-side pushing of content. Portions of content are requested and retrieved as required by a client-side application. Moreover, content likely to be needed in the near future is pre-fetched and pushed to the client. This is beneficial from an overhead standpoint since all content need not be provided to the client at once. Rather, content provisioning is throttled based on need, and wait time is mitigated by pre-fetching. | 11-20-2014 |
20150081794 | Publish/Subscribe Mashups For Social Networks - Described herein is a mashing technology that facilitates mashup creation over a plurality of publish/subscribe social network data stream. These mashing techniques that are tailored to managing content from disparate social networks. As described herein, these techniques include creating and using a set of operations that facilitate the creation of “mashups” over multiple publish/subscribe social network data streams. | 03-19-2015 |