Patent application number | Description | Published |
20090024642 | RELATIONAL SCHEMA FORMAT - A Relational Schema Definition (RSD) language that uses metadata of the relational database to generate an implementation-neutral or implementation-specific format that represents the precise database structure and data. The RSD language is a declarative description language such that an RSD file can then be used offline in a disconnected environment to reconstruct and use the database. | 01-22-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 |
20090150907 | MAPPING BETWEEN DISPARATE DATA MODELS VIA ANONYMOUS FUNCTIONS - Systems and methods that transform an input stream to an output stream by employing a hybrid of declarative features and procedural features. A transformation component includes a declaration component that identifies data types, which enables users to define customized event(s) whereupon user functions can be called, and a procedural component that executes the logic of the functions that are called to perform operations of the functions. | 06-11-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 |
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 |
20100180264 | HANDLING MULTIPLE DEFINITION OF TYPES - User assemblies can be created by a compiler that can handle more than one type definition during execution. Local copies are created for respective authoritative types in a code library, and the local copies are marked with a local type identifier. An authoritative type identifier (e.g., a globally unique identifier (GUID)) is copied from the authoritative type to the local type, and functions and properties associated with the local type are also copied from the authoritative type. Authoritative types are resolved for requested types when a local assembly references a local type from a compiled user assembly. The local type can be identified by a local type identifier, and an authoritative type can be retrieved from the code library that has a same authoritative type identifier as the requested type. A local copy of the retrieved authoritative type can be copied to the local assembly under compilation. The compiler can then emit user assemblies that comprise merely local types. | 07-15-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 |
20110154295 | Design Time Debugging - A design time debugging tool provides debugging information available from the compiler during design time, as if a user were debugging code that provided the debugging information, by exposing information available from the compiler without initiation of a debugging session and without executing the program being debugged. | 06-23-2011 |
20110167088 | EFFICIENT IMMUTABLE SYNTAX REPRESENTATION WITH INCREMENTAL CHANGE - Efficient immutable syntax representation with parent pointers under incremental change is enabled by creating a data structure comprising at least one tree structure that allows both upward and downward references in the tree and a tree structure that is immutable (read-only), and allows parts of itself to be re-used in other data structures. The data structure described enables tools to search and target particular sub trees. The fragment of the tree representing the targeted sub tree is produced as it is used. The rest of the tree is not produced. The read-only tree retains relative information, allowing it to be reassembled and shared. | 07-07-2011 |
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 |
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 |