Patent application number | Description | Published |
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 |
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 |
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 |
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 |
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 |
20110271261 | MODIFIABLE HIGH-LEVEL INTERMEDIATE REPRESENTATION OF SOURCE CODE - A computer-implemented method includes compiling one or more segments of code during run-time of a process executing at one or more processors of a computer system. The compilation produces a high-level intermediate representation of the one or more segments of the code. The high-level intermediate representation is modifiable by the process, without executing the high-level intermediate representation, to generate a modified high-level intermediate representation that is executable by the process. | 11-03-2011 |
20110276953 | DYNAMIC TOKEN RESOLUTION DURING COMPILATION - A method includes, during compilation of a portion of source code at a compiler, initiating token resolution with respect to a token included in the portion of source code. A static context and a dynamic context of the compiler are queried to identify one or more lookup results of the token. A particular lookup result is selected to resolve the token based on one or more semantic rules of the compiler. The particular lookup result is selected independently of whether the particular lookup result is sourced from the static context or from the dynamic context. The method includes resolving the token based on the selected particular lookup result. | 11-10-2011 |
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 |
Patent application number | Description | Published |
20080263063 | TRANSLATING LATE BOUND LINQ EXPRESSIONS INTO DATABASE QUERIES - There is alteration of a late-bound expression produced by a compiler into an early-bound structure. Alteration of the late-bound expression can occur at runtime and a visitor pattern can be used to create the alteration. In one instance, a conversion from late-bound to early-bound takes place through replacing a late-bound property with a statically typed call. The early-bound structure can translate into an expression tree to enable an implementation of a store specific query operated upon storage. | 10-23-2008 |
20080263531 | AUTOMATIC RUNTIME CONTROL BINDING - Binding can automatically take place between controls and information sources at runtime. This minimizes an amount of code that is to be generated by a user and thus can lower errors from the code. In addition, some wizards that allow binding without code writing can become problematic since some information is not available at runtime (e.g., when the wizard operates prior to runtime.) Relevant information is received and at least one binding is created based off received information. | 10-23-2008 |
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 |
20090150864 | DECLARATIVE OBJECT IDENTITY - Systems and methods are described that enhance a programming language by introducing support for declarative object identity in both class declarations and object literals. An exemplary system includes a memory that stores code associated with a computer program and a component coupled to the memory. The component is configured to access the code, to identify a variable in the code and a modifier associated with the variable and, responsive to identifying the variable, to use the variable to determine the identity of an object associated with the variable and to determine whether the object is equal to another object based on value semantics. | 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 |
20130263087 | THREAD-AGILE EXECUTION OF DYNAMIC PROGRAMMING LANGUAGE PROGRAMS - Methods, systems, and products are provided for thread-agile dynamic programming language (‘DPL’) program execution. Thread-agile DPL program execution may be carried out by receiving, in a message queue, a message for an instance of a DPL program and determining whether the host application has a stored state object for the instance of the DPL program identified by the message. If the host application has a stored state object for the DPL program, thread-agile DPL program execution may also carried out by retrieving the state object; preparing a thread available from a thread pool for execution of the instance of the DPL program in dependence upon the state object and an execution context for the instance of the DPL program; providing, to an execution engine for executing the DPL program, the state object and the prepared thread; and passing the message to the execution engine. | 10-03-2013 |
20140196053 | THREAD-AGILE EXECUTION OF DYNAMIC PROGRAMMING LANGUAGE PROGRAMS - Methods, systems, and products are provided for thread-agile dynamic programming language (‘DPL’) program execution. Thread-agile DPL program execution may be carried out by receiving, in a message queue, a message for an instance of a DPL program and determining whether the host application has a stored state object for the instance of the DPL program identified by the message. If the host application has a stored state object for the DPL program, thread-agile DPL program execution may also carried out by retrieving the state object; preparing a thread available from a thread pool for execution of the instance of the DPL program in dependence upon the state object and an execution context for the instance of the DPL program; providing, to an execution engine for executing the DPL program, the state object and the prepared thread; and passing the message to the execution engine. | 07-10-2014 |