Automatic Code Transformation

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.

What is claimed is: 
     
         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. 
     
     
         4 . The system of  claim 4 , the wrapper converts an instance method into a static method. 
     
     
         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. 
     
     
         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.