AUTOMATIC CODE TRANSFORMATION WITH STATE TRANSFORMER MONADS

• US 20090249310A1
• Filed: 03/28/2008
• Published: 10/01/2009
• Est. Priority Date: 03/28/2008
• Status: Active Grant

• Current Assignee: Microsoft Technology Licensing LLC (Microsoft Corporation)
• Original Assignee: Microsoft Corporation
• Inventors: Meijer, Henricus Johannes Maria, Dyer, John Wesley
• Granted Patent: US 9,317,255 B2
• Time in Patent Office: Days
• US Class Current: 717/136
• CPC Class Codes: G06F 8/24 Object-oriented
• CPC Class Codes: G06F 8/30 Creation or generation of source code
• CPC Class Codes: G06F 8/40 Transformation of program code

Abstract

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.

Claims

1. A code transformation system, comprising:

a component that receives inherently stateful code specified in an imperative programming language; and

a transform component that transforms the stateful code into stateless code in accordance with a state transform monad pattern.

2. The system of claim 1, the transform component rewrites the stateful code in a stateless state transformation form.

3. The system of claim 1, the transform component applies a wrapper to the stateful code to convert it into stateless code.

5. The system of claim 1, further comprising a tier split component that splits the stateful code for execution across multiple execution contexts.

6. The system of claim 5, intermediate state is stored on a client machine or a server.

7. The system of claim 5, a portion of intermediate state is stored on a client and a portion of the state is stored on a server.

8. The system of claim 5, intermediate state is stored on a dedicated subsystem that supports data replication.

9. The system of claim 5, further comprising a policy component that identifies where intermediate state is stored as a function of context information.

10. The system of claim 1, state is threaded between code segments with the same serialization infrastructure employed for both argument and result values.

4. The system of claim 4, the wrapper converts an instance method into a static method.

11. A code transformation method, comprising:

identifying a stateful computation in an imperative programming language; and

transforming the stateful computation into a stateless computation automatically in accordance with a state transform monad pattern, wherein state is explicit and passed as an argument and/or result.

12. The method of claim 11, comprising rewriting the stateful computation to enable state to be passed explicitly.

13. The method of claim 11, comprising applying a wrapper to the stateful computation to transform the computation.

14. The method of claim 11, further comprising splitting the computation for execution across multiple execution contexts.

15. The method of claim 14, comprising specifying storage of intermediate state on a client.

16. The method of claim 15, comprising specifying client storage where offline operation is desirable.

17. The method of claim 14, comprising specifying storage of an intermediate state on a server.

18. The method of claim 14, comprising specifying storage of an intermediate state across a client and a server.

19. The method of claim 14, further comprising specifying storage of an intermediate state separate from both a client and a server associated with computation execution.

20. A computer programming support system, comprising:

means for acquiring an inherently stateful single tier computer application specified in an imperative language;

means for automatically generating distributed code from the single tier application; and

means for automatically transforming the distributed code from stateful to stateless in a state transformer monad style to produce a scalable distributed application.