Abstract:
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.
Abstract:
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.
Abstract:
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.
Abstract:
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.
Abstract:
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.
Abstract:
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.
Abstract:
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.
Abstract:
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.
Abstract:
A spectrum of tier-splitting mechanisms facilitates distributed programming. A rich application model and associated tools enable programmers to write rich distributed applications that can run anywhere. A program can be developed simply as a single tier or tier agnostic application. Subsequently or concurrently, the program can be sliced into multiple tiers in different ways to reflect, for instance, capabilities and/or constraints of a server, client and/or network.
Abstract:
A compositional application programming interface (API) permits non-sequential construct declaration independent of other API calls. A wrapper is applied to an imperative API to provide a compositional interface that enables arbitrary and autonomous construct declaration. Additionally, a literal syntax (e.g., code literals, graphic literals . . . ) affords a convenient declaration mechanism for such constructs.