Compilation and execution of source code as services

1. A method performed by a computing device, the method comprising:

receiving input source code in imperative programming form;

identifying one or more data dependencies in the input source code;

based at least on the one or more data dependencies, identifying one or more immutability points in the input source code where one or more particular data items cease to be modified by the input source code;

based at least on the one or more immutability points, determining that a first instance of a particular function operates on an immutable local variable and a second instance of the particular function operates on a mutable local variable; and

based at least on the determining that the first instance of the particular function operates on the immutable local variable, converting the first instance of the particular function into one or more service modules in functional programming form,

wherein the second instance of the particular function remains in the imperative programming form based at least on the determining that the second instance of the particular function operates on the mutable local variable.

2. The method of claim 1 , wherein identifying the one or more data dependencies comprises constructing a graph with nodes and edges representing the one or more data dependencies.

3. The method of claim 2 , wherein the graph is a directed acyclic graph.

4. The method of claim 1 , wherein the converting further comprises:

creating service tasks to execute instances of the one or more service modules.

5. The method of claim 4 , further comprising:

based at least on the one or more data dependencies, identifying at least two service tasks that can run in parallel; and

configuring the at least two service tasks to execute in parallel at runtime.

6. The method of claim 5 , wherein the identifying the one or more data dependencies comprises identifying at least one data item that is updated in only one iteration of a loop in the input source code.

7. The method of claim 4 , further comprising:

based at least on the one or more data dependencies, detecting that a particular service task depends on output of another service task; and

configuring the particular service task to await output of the another service task at runtime.

8. The method of claim 7 , wherein the identifying the one or more data dependencies comprises detecting at least one data item that is updated in multiple iterations of a loop in the input source code.

9. The method of claim 1 , wherein the particular function is a member function of a particular class instance.

10. The method of claim 9 , wherein the first instance of the particular function receives the immutable local variable as an argument and the second instance of the particular function receives the mutable local variable as an argument.

11. A system comprising:

a hardware processing unit; and

a storage resource storing computer-readable instructions which, when executed by the hardware processing unit, cause the hardware processing unit to:

receive input source code for an application, the input source code being received in imperative programming form;

identify one or more data dependencies in the input source code;

based at least on the one or more data dependencies, identify one or more immutability points in the input source code where one or more particular data items cease to be modified by the input source code;

based at least on the one or more immutability points, determine that a first instance of a particular function operates on an immutable local variable and a second instance of the particular function operates on a mutable local variable;

based at least on determining that the first instance of the particular function operates on the immutable local variable, convert the first instance of the particular function into one or more service modules in functional programming form; and

consistently with the one or more data dependencies, schedule service tasks that execute the one or more service modules at runtime,

wherein the second instance of the particular function remains in the imperative programming form based at least on determining that the second instance of the particular function operates on the mutable local variable.

12. The system of claim 11 , wherein the computer-readable instructions, when executed by the hardware processing unit, cause the hardware processing unit to:

access one or more execution logs reflecting prior executions of the one or more service modules; and

schedule the service tasks based at least on the one or more execution logs.

13. The system of claim 11 , wherein the computer-readable instructions, when executed by the hardware processing unit, cause the hardware processing unit to:

based at least on the one or more data dependencies, identify ordering constraints for executing the service tasks; and

run the service tasks consistently with the identified ordering constraints.

14. The system of claim 13 , wherein the computer-readable instructions, when executed by the hardware processing unit, cause the hardware processing unit to:

in at least one instance, run multiple service tasks in parallel as indicated by the ordering constraints.

15. The system of claim 13 , wherein the computer-readable instructions, when executed by the hardware processing unit, cause the hardware processing unit to:

in at least one instance, run multiple service tasks in series as indicated by the ordering constraints.

16. The system of claim 11 , wherein the computer-readable instructions, when executed by the hardware processing unit, cause the hardware processing unit to:

compile a portion of the input source code into imperative bytecode;

execute the imperative bytecode to obtain result data; and

provide the result data as input data to individual service tasks when available.

17. The system of claim 11 , wherein the computer-readable instructions, when executed by the hardware processing unit, cause the hardware processing unit to:

output a workflow module that relates the service tasks; and

coordinate runtime communication among the service tasks according to the workflow module.

18. A method performed by a computing device, the method comprising:

obtaining a first instance of a particular function in imperative form, a second instance of the particular function that operates on an immutable local variable and has been converted to one or more service modules, and a partial dependency graph of service tasks for executing the one or more service modules, the first instance of the particular function remaining in the imperative form based at least on a determination that the first instance of the particular function operates on a mutable local variable;

executing the first instance of the particular function and the service tasks in an application process;

detecting a particular runtime value that is output by a particular service task;

based at least on the particular runtime value, inserting one or more additional service tasks into the partial dependency graph to obtain a completed dependency graph; and

based at least on the completed dependency graph, executing the one or more additional service tasks in the application process.

19. The method of claim 18 , further comprising:

obtaining a workflow module that defines the service tasks; and

executing the service tasks in the application process according to the workflow module.

20. The method of claim 18 , further comprising:

based at least on the completed dependency graph, identifying at least two additional service tasks that can be run in parallel; and

scheduling the at least two additional service tasks to run in parallel in the application process.

21. The method of claim 20 , wherein the particular runtime value comprises a loop counter.