Patent Publication Number: US-10776170-B2

Title: Software service execution apparatus, system, and method

Description:
CROSS-REFERENCE TO RELATED APPLICATIONS 
     This application claims the benefit of German Application No. 102016220778.4, filed Oct. 21, 2016, in the German Intellectual Property Office, the disclosure of which is incorporated herein by reference. 
     FIELD 
     Embodiments lie in the field of data processing architectures and in particular relate to the automatic orchestration of software services, such as web software services. 
     BACKGROUND 
     The automatic orchestration and composition of software services, such as web services that are already micro-services is uncommon, and state of the art approaches rely upon heavy annotations of the web services. 
     Existing techniques seeking to automate the orchestration and composition of web service fall into two broad groups:
         Those that do not make any decision: all the possibilities to be executed are executed, and the result is equivalent due to set semantics.   Those that make decisions based on formal logic, which in most advanced cases have two elements:   a. Some metadata about the quality of the service that is provided by the service.   b. An orchestration algorithm that uses such metadata to find a plan adjusting to the quality requested by the user or a set of rules.       

     The problem is that the orchestration is not autonomous, and the annotations are too heavy. It is difficult to annotate new services, and execution planning is onerous. There are some scenarios in which set semantics cannot be applied, and in some other scenarios set semantics may imply a huge computational cost. Therefore, it is desirable to find a system for orchestrating software services in a more selective manner. 
     SUMMARY 
     Embodiments include: a software service execution apparatus, comprising: a registry identifying each of a plurality of software services, each identified software service being configured to execute a respective data processing function specified in the registry; a software execution controller, configured to, for each of a plurality of data processing requests: receive the data processing request, the received data processing request defining one or more requested data processing functions, compose an execution schedule, of one or more software services from among the plurality of software services identified in the registry, to fulfill the received data processing request by, for each of the one or more requested data processing functions, identifying a software service for which the processing function specified in the registry matches the requested data processing function, and including the identified software service in the execution schedule; and control execution of the execution schedule. The apparatus further comprises: a machine learning mechanism configured to maintain, for each of the received data processing requests, a record of the composing of the execution schedule and the execution of the execution schedule; wherein: the composing includes, in an automated composing mode, if more than one software services is identified for which the single processing function specified in the registry matches one of the requested data processing functions, requesting a selection of one software service from among the more than one software services as automated selection candidates by the machine learning mechanism; the machine learning mechanism being configured to respond to the request for selection with a selection of one software service from among the automated selection candidates, basing the selection on an analysis of records of the composing and execution of execution schedules in which any of the automated selection candidates is identified or executed. 
     Advantageously, embodiments leverage a machine learning mechanism to utilize knowledge about previous compositions of execution schedules and executions of the software services, to decide on the composition of a current execution schedule. By recording information about the composing of execution schedules and the execution thereof, the machine learning mechanism builds up a knowledge base which can be called upon to “break ties” (i.e. choose between them) where plural software services are suitable for performing processing to satisfy a requested data processing function. 
     Advantageously, such a machine learning mechanism enables intelligent scheduling of software services to satisfy a received data processing request in the absence of manual input. It is noted that manual inputs in satisfying previous data processing requests may be utilized by the machine learning mechanism. 
     Optionally, each software service among the plurality of software services identified in the registry is configured, in response to a call from the software execution controller, to execute processing to perform the respective data processing function on input data identified in the call, an outcome of said executed processing being either output of a processing result or a timeout; and controlling execution of the execution schedule comprises calling the or each of the software services included in the execution schedule to perform the respective data processing function specified in the registry on input data determined by the received data processing request and/or preceding software services included in the execution schedule. 
     Advantageously, by such an arrangement of software services and execution controller, software services are executable in a series or chain of processing in which the processing result of a preceding software service in the execution schedule is the input data of a proceeding software service in the execution schedule. Specifically, the processing software service in the execution schedule may be the immediately proceeding software service in the execution schedule. 
     A call is an instruction to execute. The registry may store, for each of the software services, a definition of how to call the software service to execute. The definition includes the syntactic and semantic information necessary for the software execution controller to generate and issue a call to the software service to perform its respective data processing function. 
     Furthermore, it may be that the record of the execution of the execution schedule maintained by the machine learning mechanism includes, for each of the software services called by the software execution controller in the controlled execution of the execution schedule for the respective data processing request, an indication of the outcome of the executed processing of the software service, as either a timeout or output of a processing result; and the machine learning mechanism being configured to base the selection of one software service from among the automated selection candidates, at least partially, on the recorded indications of executed processing outcomes for the automated selection candidates. 
     When called to execute by the software execution controller, the software service is executed, and either successfully generates a processing result, or reaches a timeout without completing the processing required to generate the processing result. Timeout is either a maximum time-to-result defined by the software service (starting from the start of execution), which when reached terminates execution and issues a timeout message to the software execution controller, or a maximum time-to-result set by the software execution controller (starting from the call to execute), which when reached corresponds to an assumption by the software execution controller that no processing result will be output and hence an alternative software service is identified and executed. 
     The machine learning mechanism monitors execution of the software services and records when a called software service times out and when a called software service successfully outputs a processing result. 
     As a further option, it may be that the record of the execution of the execution schedule maintained by the machine learning mechanism further includes, for each of the called software services, values of one or more characteristics of the input data identified in the call; the machine learning mechanism being configured to base the selection of one software service from among the automated selection candidates, at least partially, on a quantification of similarity between values of characteristics of the input data for the requested data processing function and the recorded values of the one or more characteristics of the input data identified in calls for which the outcome of the executed processing is output of a processing result. 
     Advantageously, the machine learning mechanism is able to learn how characteristics of input data influence composing and execution of execution schedules. Such learning is used as a factor upon which to base the selection of a software service to fulfill a requested data processing function. 
     Basing a selection at least partially on a piece of information means that the piece of information is a factor contributing to the decision of which software service to select. For example, each of said factors may be attributed a weighting in an analysis operation (by the machine learning mechanism) to quantify suitability of each of the automated selection candidates as a determination of selection (i.e. the highest-ranked by said quantification is selected). In implementation terms, the machine learning mechanism may include, in addition to the knowledge base (records), a neural network, with those pieces of information upon which the selection is at least partially based being input nodes, and a selection of a software service from plural automated selection candidates being the output node. 
     Furthermore, the one or more characteristics of the input data may include a measurement of the amount of input data. 
     For example, such a measurement may be obtained by reference to a management service, controller function, or data storage function from which the input data is accessible. The measurement may be performed by the software execution controller itself, or performed by a separate entity. 
     Advantageously, certain of the software services may have execution characteristics that predispose them to successfully generate a processing output, or to timeout, with certain ranges of input data size. The machine learning algorithm can learn these predispositions by observation and leverage such learning in selecting software services for inclusion in the execution schedule. 
     In a particular implementation of the composing procedure, the composing includes, in a manual composing mode, if more than one software services is identified for which the single processing function specified in the registry matches one of the requested data processing functions, requesting a selection of one software service from among the more than one software services as manual selection candidates by a user of the apparatus, and receiving the requested selection from the user; and the machine learning mechanism is configured to include in the record of the composing of the execution schedule for the respective data processing request the identity of the manual selection candidates and an indication of the received user selection; the machine learning mechanism being configured to base the selection of one software service from among the automated selection candidates, at least partially, on the recorded indication of the received user selection from among manual selection candidates including one or more of the automated selection candidates. 
     The machine learning mechanism is employed to make a selection from among automated selection candidates (the automated implying the responsibility of the machine learning mechanism). Records are maintained of selections made by a user from among manual selection candidates. 
     Advantageously, the machine learning mechanism learns from user preferences which software services are favored when there are plural suitable to fulfill a requested data processing function. Such learning is a contributory factor in the analysis of the machine learning mechanism to determine a selected software service from plural automated selection candidates. 
     It may be that the only recorded indications of user selections that are deemed relevant are those in which there is an exact match in the membership of the automated selection candidates (from which the machine learning mechanism is making a selection) and the membership of the manual selection candidates from which the recorded user selection was made. Alternatively, it may be that recorded indications of user selections are deemed relevant as long as one of the automated selection candidates (from which the machine learning mechanism is making a selection) was among the manual selection candidates. For example, it could be that a quotient is calculated, for each of the automated selection candidates, based on a ratio of selections (from manual selections in which the respective automated selection candidate was among the manual selection candidates) to non-selections. 
     Optionally, all records are given equal weight. As an alternative, more recent records may be weighted higher than less recent records. As a further alternative, similarity of the input data in the record to the input data in the requested data processing function for which a software service is being selected may be taken into account. 
     The software execution controller need not be fixed in a particular composing mode for an entire execution schedule. Indeed, automated may be a default mode, with the software execution controller being configured to adaptively revert to manual composing mode for particular elements of the composing. 
     Optionally, the machine learning mechanism is configured to generate a degree of confidence in the selection of one software service from among the automated selection candidates as an outcome of the analysis of records of the composing and execution of execution schedules in which any of the automated selection candidates is identified or executed; the composing including, if the generated degree of confidence is above a threshold minimum value, adding the selection of one software service to the execution schedule, and if the generated degree of confidence is at or below the threshold minimum value, reverting to the manual composing mode for a selection of one software service to perform the requested data processing function. 
     For example, the degree of confidence may be the quotient mentioned above, calculated for each of the automated selection candidates based on a ratio of selections (from manual selections in which the respective automated selection candidate was among the manual selection candidates) to non-selections. The degree of confidence may be calculate by a binomial test of statistical significance, the two outcomes being selection in a composing record or non-selection in a composing record. 
     As a particular implementation of the record of composing maintained by the record of the composing of the execution schedule maintained by the machine learning mechanism includes, for each of the one or more requested data processing functions defined by the received data processing request, values of one or more characteristics of the input data identified in the call; the machine learning mechanism being configured to base the selection of one software service from among the automated selection candidates, at least partially, on a quantification of similarity between values of characteristics of the input data for the requested data processing function and the recorded values of the one or more characteristics of the input data in records of composing in which the manual selection candidates includes one or more of the automated selection candidates. 
     Optionally, the one or more characteristics of the input data includes a measurement of the amount of input data. 
     Optionally, a quotient may be built up for each of the automated selection candidates (from which a selection is being made by the machine learning mechanism). Such a quotient may be built up, for example, by incrementing a total for each record in which the respective automated selection candidates was among the manual selection candidates and selected, and decrementing the total for each record in which the respective automated selection candidates was among the manual selection candidates and not selected. The value of the increment or decrement in each case may be in proportion to the similarity between the input data in the case of the record to the input data in the case of the present selection. 
     Optionally, the one or more requested data processing functions defined by the received data processing request are defined as a series of requested data processing functions, and the composing of the execution schedule is performed for each requested data processing function following the composing and execution of the execution schedule for any preceding requested data processing functions defined by the data processing request. 
     Advantageously, composing the execution schedule in an adaptive rather than prescriptive manner enables account to be taken of the processing outcomes of preceding software services in the execution schedule and, in particular, the processing results thereof. 
     In which context, series is taken to mean defining an order of processing, and the output of a preceding data processing function in the series forming the input of the adjacent proceeding data processing function in the series. 
     Embodiments may further comprise a software execution processor, being configured to respond to a call from the software execution controller identifying a software function from among the plurality of software functions and identifying input data, to load and execute the identified software service with the identified input data as input data in the execution. 
     Furthermore, the apparatus may include a software library storing the plurality of software services on a memory. 
     Embodiments of another aspect include: a software service execution method, comprising: storing a registry identifying each of a plurality of software services, each identified software service being configured to execute a respective data processing function specified in the registry; and for each of a plurality of data processing requests: receiving the data processing request, the received data processing request defining one or more requested data processing functions; composing an execution schedule, of one or more software services from among the plurality of software services identified in the registry, to fulfill the received data processing request by, for each of the one or more requested data processing functions, identifying a software service for which the single processing function specified in the registry matches the requested data processing function, and including the identified software service in the execution schedule; and controlling execution of the execution schedule. The method further comprises: maintaining, for each of the received data processing requests, a record of the composing of the execution schedule and the execution of the execution schedule; wherein: the composing includes, in an automated composing mode, if more than one software services is identified for which the single processing function specified in the registry matches one of the requested data processing functions, requesting a selection of one software service from among the more than one software services as automated selection candidates by the machine learning mechanism. The method further comprises: responding to the request for selection with a selection of one software service from among the automated selection candidates, basing the selection on an analysis of records of the composing and execution of execution schedules in which any of the automated selection candidates is identified or executed. 
     Embodiments of another aspect include a computer program which, when executed by a computing apparatus, causes the computing apparatus to function as a system defined in the claims. 
     Embodiments of another aspect include a computer program which, when executed by a computing apparatus, causes the computing apparatus to perform a method defined above or elsewhere in this document. 
     Furthermore, embodiments include a computer program or suite of computer programs, which, when executed by a plurality of interconnected computing devices, cause the plurality of interconnected computing devices to operate as a system embodiment. 
     In any of the above aspects, the various features may be implemented in hardware, or as software modules running on one or more processors. Features of one aspect may be applied to any of the other aspects. 
     The embodiments also provide a computer program or a computer program product for carrying out any of the methods described herein, and a computer readable medium having stored thereon a program for carrying out any of the methods described herein. 
     A computer program embodiment may be stored on a computer-readable storage medium. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       Embodiments will now be described, purely by way of example, with reference to the accompanying drawings, in which:— 
         FIG. 1  illustrates a software service execution apparatus; 
         FIG. 2  illustrates a software service execution system; 
         FIG. 3  illustrates a procedure for adding a new software service to the system and composing execution schedules including the new software service; 
         FIG. 4  illustrates exemplary registry entries for a sample set of micro-services; 
         FIG. 5  illustrates a general procedure of an embodiment; 
         FIG. 6  illustrates a processing flow in a first worked example; 
         FIG. 7  illustrates a processing flow in a second worked example; 
         FIG. 8  illustrates a processing flow in a third worked example; and 
         FIG. 9  illustrates a hardware configuration of an embodiment. 
     
    
    
     DETAILED DESCRIPTION 
     Reference will now be made in detail to the embodiments, examples of which are illustrated in the accompanying drawings, wherein like reference numerals refer to the like elements throughout. The embodiments are described below by referring to the figures. 
       FIG. 1  illustrates a software service execution apparatus  10 . The apparatus  10  comprises a registry  12 , a software execution controller  14 , and a machine learning mechanism  14 . A selection of data exchanges useful in illustrating the operation of the apparatus  10  are represented in  FIG. 1 , the illustrated selection of data exchanges is not exhaustive. 
     The software execution apparatus  10  may be, for example, a web server or other server-side computing apparatus configured to receive data processing requests from a user. Such a user may operate the apparatus  10  directly, or may access the software execution apparatus (i.e. send data processing requests thereto) via a web client or other client-side computing apparatus connectable to the software execution apparatus via a network. In particular, a user may issue a data processing request to the apparatus  10 , which is received by the software execution controller  14 , as illustrated by the arrow labeled “data processing request” in  FIG. 1 . 
     The registry  12  may be a document or other form of data stored in persistent storage by the software service execution apparatus  10 . The registry  12  may be a data storage unit having physical data storage arranged to store the data of the registry  12 . The registry  12  may store information related to each software service as a registry entry, for example, the identity of the software service being a primary key. The registry  12  may store data as relational data, with one row per software service, or as graph data, with each software service identifiable by a predicate linking the input and processing result of the software service as vertices in the graph. 
     Each of the plurality of software services identified by the registry  12  may be identified, for example, by a URL (uniform resource locator) or URI (uniform resource identifier) at which the software service is accessible. Accessible in this context is taken to mean a (virtual or physical) location at which calls to the methods of the software service may be issued. The identification of the software service may include, for example, an API defining how the software service is usable. 
     The data processing function for each software service in the registry  12  may be defined semantically (for example, “tokenize”; “load”; “summarize”; “compare”), the semantic definition being a semantic descriptor of the data processing executed by the respective software service. Such semantic definition may also be (wholly or partially) a URL or URI at which the software service is accessible. In addition, or as an alternative, to the semantic definition, the data processing function may be specified in terms of the input data and output data of the data processing. For example, a data type, which may be indicated by a filename, file type, or by a semantic descriptor of the data type, may be specified for the input data and/or the data processing result (output data). 
     The apparatus may further comprise a registry of types, wherein the semantic descriptors of the data type are constrained to be one or more types from the registry of types. The registry of types may be domain specific. 
     The software execution controller  14  is a functional module, which may be a programmed processor (CPU or GPU), programmed by stored (on a memory) processing instructions. In addition, the software execution controller  14  is configured to communicate with the plurality of software services (via the respective registry entry) and, for example, with the machine learning mechanism  16 , and/or with an apparatus user. The software execution controller  14  may comprise an I/O interface for communicating with the software services locally or over a network, using information stored in the registry  12 . The software execution controller  14  may comprise an interface for receiving input from a user. The interface may be local or may be, for example, a GUI implemented in a client-side apparatus from which inputs are accessible by the software execution controller  14 . 
       FIG. 1  illustrates a data processing request received by the software execution controller  14  being divided into three constituent data processing functions, three being merely an example to illustrate the principle of operation. The received data processing request defines one or more requested data processing functions. It may be that some processing of the data received data processing request is performed by the software execution controller in order to determine the constituent requested data processing function(s). That is to say, the constituent data processing function(s) may be implicitly defined by the received data processing request and extracted (i.e. made explicit) by the software execution controller  14 , for example, by reference to the data processing functions specified in the registry  12 . An order in which the constituent data processing functions are to be performed in order to fulfill the data processing request may also be defined by the data processing request. 
     An execution schedule is a plan identifying which software services to execute, in which order (noting that the order may include parallel execution of plural software services), and with which input data. The composing and control of execution are not necessarily steps performed serially. It may be that the composing is adaptive rather than prescribed or predetermined. The composition of an element of the execution schedule may be dependent upon the outcome of execution of preceding software services in the execution schedule. 
     The line marked “composing” between the registry  12  and software execution controller  14  in  FIG. 1  illustrates the use of information in the registry to compose the execution schedule. The execution schedule is composed by the software execution controller  14  in order to fulfill the received data processing request, by using information stored in the registry  12  about the software services. For example, it may be that the received data processing request specifies input data and a particular data type sought in return, for example, specifying the particular data type semantically or by use of a particular filename or group of filenames. The execution schedule is composed by the software execution controller  14  by determining a software service or series of software services listed in the registry  12  which, when executed (in the case of a series, with proceeding software services in the series taking as an input the processing result(s) of one or more preceding software service(s) in the series) transform the input data specified in the data processing request into output data satisfying the particular data type sought in return. 
     Each of the software services is configured to execute a respective data processing function. The data processing executed by each of the software services transforms input data of a particular type into output data of a particular type. The exception to this singular input type to output type relationship is the event of a failure of the software service, such as a timeout, which does not generate output data of the output type. Type means a type of data, and may be specified by, for example, a single or group of filename extensions or file types, and/or by a semantic descriptor or descriptor(s) of the data. 
     Controlling execution of the execution schedule by the software execution controller  14  is a process of issuing calls to the respective software services to execute, in the order/timing determined by the execution schedule, and with input data specified by the execution schedule. The line marked “execution calls (and response)” between the software execution controller  14  and the registry  12  in  FIG. 1  illustrates the control of execution, and the optional response detailing the outcome and processing result of said execution. For example, controlling execution comprises calling the or each of the software services included in the execution schedule to perform the respective data processing function specified in the registry on input data specified in the call. The input data may be specified by the received data processing request and/or the processing result of preceding software services included in the execution schedule. Input data may be specified by reference to a URI or URL from which it is accessible. 
     An outcome of the execution may be returned to the software execution controller  14  in response to the execution call, for use in composing the remainder of the execution schedule for the respective data processing request. The outcome may be, for example, an indication of whether a processing result was generated or whether the execution timed out. Optionally, the response may include information such as a measurement of the size of data output by the executed software service as a processing result. 
     The execution calls and response thereto are illustrated as being between the software execution controller  14  and the registry  12 . This is representative of the software services themselves being accessible via information stored in the registry  12 . 
     The composing process may be performed by the software execution controller  14  in a manual mode (requiring input from a human user of the apparatus) or in an automatic/automated mode. In an automated mode, the machine learning mechanism  16  is called on to select between plural software services suitable for performing a particular requested data processing function, as illustrated by the line marked “selection request &amp; response” in  FIG. 1 . In a manual mode, input of a user is called on to select between plural software services suitable for performing a particular requested data processing function. 
     A match between a data processing function specified for a software service in the registry  12  and a requested data processing function is an indication that the software service for which the single processing function is specified is suitable to perform the requested data processing function. The match is based on the definition of the requested data processing function, and the data processing function specified for the software service in the registry  12 . The match may be based on semantics, for example, the data processing function is defined semantically in the registry  12  (for example, “tokenize”; “load”; “summarize”; “compare”) and the requested data processing function is defined semantically using the same or similar term(s), so that a semantic comparison between the semantic definition of the requested data processing function and the semantic definition of the data processing function yielding a similarity score above a threshold is taken to be a “match”. Alternatively or additionally, the definition of the requested data processing function may be defined in terms of input data and requested processing result, for example, defining each by a semantic descriptor of the data type (“tabular data” “matrix” “document” “vector”) or by a filename extension. The data processing functions specified in the registry  12  may be defined in the same way, so that a match is matching input and output filename extensions, or matching (i.e. semantic similarity above a threshold) input and output semantic data type descriptors. A data type descriptor is a semantic representation of the structure of the data and of the composition of data items. 
     The record maintained by the machine learning mechanism may be termed a knowledge base. 
     Whether the software execution controller  14  performs composing an automated mode or a manual mode is controllable by a user, for example, via an interface providing controls to the software execution controller  14 , or by specifying particular arguments in the data processing request. 
     The machine learning mechanism monitors the operation of the software execution controller  14  and maintains a record, as indicated by the lines marked “record” in  FIG. 1 . In particular, the record maintained by the machine learning mechanism may detail the data processing request, the composing of the execution schedule (in terms of identified manual/automated execution candidates and selections), and the execution (in terms of outcome of the execution and characteristics of the execution and input/output data). 
     Records of composing identify when more than one software service is identified for which the single processing function specified in the registry matches one of the requested data processing functions (i.e. when there are plural automated/manual execution candidates from which a selection is made), and which among the more than one was/were selected for inclusion in the execution schedule. In addition, an indication of whether the composing was performed in a manual or automated composing mode may be recorded. 
     Records of execution identify which software services were executed, and in which order. Optionally, records of execution may also store values of execution characteristics, such as time to execute, time of execution (as in, time of day), outcome of execution (timeout or output of data processing result). 
     Records of execution or records of composing may also store values of characteristics of the input data to the executed software service (in the case of records of execution) or the input data for which a software service is selected (in the case of records of composing). Characteristics may include, for example, data size (in terms of storage space), data type, filename or file type, whether stored locally or remotely, whether available in a local cache, characteristics may also include statistical characteristics of the values of the data items themselves. 
     Records of execution may also store values of characteristics of the processing result (output data) output by the executed software service. Characteristics may include, for example, data size (in terms of storage space), data type, filename or file type, whether stored locally or remotely, whether available in a local cache, characteristics may also include statistical characteristics of the values of the data items themselves. 
     The records maintained by the machine learning mechanism  16  provide knowledge to inform future selections between plural selection candidates (i.e. selection candidates being more than one software services identified by the software execution controller for which the single processing function specified in the registry matches one of the requested data processing functions). The identifying of candidates by the software execution controller  14  is based on predefined (i.e. defined by a software developer or apparatus administrator on addition to the registry) information about the software service which is compared (matched) to defined elements of the data processing request. The selection between plural candidates performed by the machine learning mechanism  16  is based on information (i.e. records) about previously-performed composing and execution of execution schedules. 
       FIG. 2  illustrates a software service execution system. In addition to the software service execution apparatus  10 , the system comprises a software library  20 . The software library stores a plurality of executable software services. In the example illustrated in  FIG. 2 , the software services are micro-services.  FIG. 2  illustrates that each of the micro-services in the software library  20  is accessible via information stored in a respective entry in the registry  12 . 
     A micro-service is an atomic service in a data processing apparatus. Atomic in this context means single responsibility or single function. A micro-service is distinguished from a generic web service by the dimension of service. For example, a generic web service would include some form of authentication as part of a wider functionality. In a micro-service-based apparatus, authentication is a dedicated micro-service. 
     The software services, whether micro-services or otherwise, may be RESTful software services, each defining methods for GET, and POST and/or PUT requests. 
     REST (Representational State Transfer) is an architectural style which governs the proper behavior of participants in the web for machines. REST sets out constraints for system architectures to which conforming is described as being ‘RESTful’, the first of which is that the architecture has a client-server arrangement, with clients being separated from servers by a uniform interface. There are four guiding principles of the interface between client and server, and an interface developed in accordance with these principles can be described as ‘RESTful’. For example, an API can be written in accordance with the REST guiding principles for interfaces to the software services, and would hence be described as a ‘RESTful API’. Such a restful API for a software service may be stored in the registry entry for a software service, or stored in a location made accessible (for example, by a reference) in the registry  12 . HTTP as a protocol can be used in a RESTful manner, and RESTful HTTP is suitable for the web for machines. RESTful interfaces (APIs) are popular for a number of key reasons: there is simplicity of the basic protocol built on a proven foundation with solid architectural principles, and the result is approachable and usable by web developers. 
     In brief, the REST architectural style describes six constraints (one of the six is optional) on a system architecture are as follows:
         the architecture should be client-server;   the client and server are separated by a uniform interface;   the architecture is stateless, meaning that no client context is stored on the server between requests from the client—each request contains all of the information necessary to service the request, with state information held in the client itself;   clients are able to cache responses;   (optional) functionality may be extended by a server transferring logic to a client which the client can execute.       

     In the context of the software service execution system, the client is the entity making the data processing request, and the server is the web server or other computing device executing the software services. 
     The guiding principles for the uniform interface are briefly summarized below:
         individual resources in the domain can be identified in requests from the client (this would be via URIs (Universal Resource Identifiers) in a web-based system). The resources themselves are separate entities from the representations returned to the client;   the representation of a resource held by a client is sufficient to give the client enough information to modify or delete the resource on the server (permissions allowing);   each message between client and server contains enough information for the recipient to process the message;   the representation of a resource provided from the server to the client should include hypertext links to related resources.       

     A positive aspect of the REST architectural style is that it links well with information models, an information model being a formalized description of items in a domain and relationships between those items. The operations allowed in a RESTful API are constrained (fixed), this avoids the unwanted side effects of poor programming behavior which would ordinarily lead to problems in linking an interface with an information model. 
     In fact, a RESTful API for a particular domain may be defined purely in terms of the information model for the domain, and by how this model then appears inside different data formats, the data formats being wire level (low level or implementation level) manifestations of the information model. Unfortunately, APIs currently in use show disparities regarding their approach to information modeling, how this appears inside data formats, and how the semantics of HTTP are brought to use in the specific domain of the API(s) in question. This lack of consistency is problematic since potential benefits of a RESTful protocols are lost, for example, the potential for re-usable toolkits (eg. standard code) and generic client agents (equivalent to a browser). 
       FIG. 3  illustrates a procedure for adding a new software service to the system and composing execution schedules including the new software service. 
     Due to the nature of the system, micro-services traverse a number of states. 
     At step S 301 , a micro-service is created, with some specification that is implemented. The created micro-service is uploaded to the software library  20 , which is kept running by restarting (in a trivial way) if necessary. 
     At step S 302 , the micro-service is registered in the registry  12 , and metadata of the micro-service is stored in a registry entry. For example, if the respective micro-service is RESTful, information enabling calls to be made to the HTTP GET, PUT, POST, &amp; DELETE methods may be stored in the registry entry. In addition, the registry entry defines input data and output data (processing result) of the data processing function, for example, by semantically describing said data, and/or by specifying file types, data types, and/or filename extensions. Optionally, the registry entry may also detail how to issue a call to the micro-service in a test mode. Optionally, the registry entry may also detail how to issue a call to the micro-service to output documentation related to the micro-service, for example, source code. 
     At step S 303 , the micro-service is “discoverable”. In other words, once they are registered in the registry  12 , micro-services can be discovered by the software execution controller  14  whenever they may be useful for a requested data processing function. The software execution controller  14  queries the registry  12  for software services for which the registry entry indicates it is compatible with the input data for processing in a requested data processing function. 
     At step S 304 , the micro-service, having been included in an execution schedule by the software execution controller  14 , is called with the inputs (i.e. the micro-service is either told to execute or told to execute and where to access input data), either retrieving the processing result which is output, or timing out, leading the software execution controller  14  to call a different micro-service to perform the requested data processing function. 
     At step S 305 , the execution of the micro-service is monitored by the machine learning mechanism  16 . Of course, the monitoring may actually be performed by components of the execution platform on which the micro-service is executed, such as operating system components, with the monitoring by the machine learning mechanism  16  being a read access to the relevant information. The machine learning mechanism  16  monitors the execution including, for example, the data processing request in response to which the micro-service is executed (and optionally also the particular requested data processing function being fulfilled), characteristics of the data (for example, size, format, type), the performance of the micro-service (time to solution, timestamp of start of execution), and other relevant aspects of the composing and execution of the execution schedule. The results of the monitoring are recorded in a knowledge base component of the machine learning mechanism  16 . 
     At step S 306 , in a learning or training phase, algorithms forming the machine learning mechanism  16  (segmentation, regression, prediction, etc.) are fed with the recorded information about execution of micro-services and a model for selecting micro-services is trained to improve outcomes. Outcomes may be, for example, match between selections in manual and automated composing modes. For example, information about input data for a selection between micro-services in a manual composing mode, and result of the selection, is used to train a model for making automated selections between the same micro-services by configuring how much weight is given to similarities/differences between various characteristics of the input data. 
       FIG. 4  illustrates exemplary registry entries for a sample set of micro-services, which microservices will be used in the below worked examples. The information per registry entry illustrated in  FIG. 4  is not necessarily a complete registry entry, but illustrates information identifying each software service, and a semantic descriptor of the input data and processing result. The identifying information may be sufficient to locate the software service within the software library  20 , for example, if the software library is implemented as a key value store in which the identifying information is the key. 
     The registry  12  is empty prior to the addition of four micro-services, identified by respective ID numbers 1 to 4. 
       FIG. 5  illustrates a general procedure of an embodiment. The general procedure is for populating a registry and handling received data processing requests. Specific instances of particular elements of the procedure will be set out with reference to three worked examples, illustrated by  FIGS. 6 to 8 . 
     At step S 501 , services are added to the registry. In terms of the worked examples, two micro-services are added to the registry and assigned ID numbers 1 and 2. Both micro-services are for the generation of tabular data. The micro-service assigned ID number 1 has a processing function of generating tabular data from plain text files (CSV, TSV, etc). Optionally, the “input” element of the registry entry details the acceptable file types, for example, by listing acceptable filename extensions. 
     The micro-service assigned ID number 2 has a processing function of generating tabular data from databases by doing a natural join of their tables. 
     Two further micro-services are added to the registry  12 , both performing the same function: summarize tabular data. In this case one micro-service, assigned ID number 3, is suitable for big data, while the other implementation, assigned ID number 4, provides a quick overview in milliseconds if the input data fits comfortably in a local memory. 
     The registry obtains (for example, from a system administrator) the information about the inputs and outputs of the services, both from syntactic and semantic points of view. 
     The four micro-services are now registered. At step S 502 , an execution schedule is requested as a response to receiving a data processing request at the software execution controller  14 . The information stored in the registry  12  enables the software execution controller  14  to detect the possibilities for coordination between the micro-services, and hence at step S 503  to select micro-services to execute to fulfill the data processing request. 
     In the worked examples, several execution schedules will be requested. Step S 501  is part of an initialization procedure which is to be carried out in order to add a new micro-service to the system, and does not form part of the procedure for responding to a particular received data processing request, which is represented by steps S 502  to S 506 . 
     At step S 504 , the software execution controller  14  controls the micro-services to execute in accordance with the execution schedule. At step S 505 , the processing result requested in the data processing request is output. In all cases, at step S 506  the system (specifically, the machine learning mechanism  16 ) records performance statistics about the micro-services executed and about the composing of the execution schedule. 
       FIG. 6  illustrates a flow of processing in a first worked example. A data processing request is received requesting the summary of a CSV file. The software execution controller, by reference to information in the registry  12 , identifies two requested data processing functions defined by the request (because there is no single function generating a summary from CSV input data). The requested data processing functions are PF 1 , “GET TABULAR DATA”, and PF 2 , “GET SUMMARY”. In the present example, the machine learning mechanism  16  has not yet built up a knowledge base upon which to base selections in an automated composing mode, and hence the software execution controller  14  composes the execution schedule in a manual composing mode. 
     At step S 601 , composing, based on the information provided in the registry entries and knowledge of the data type of the input data specified in the data processing request, the software execution controller  14  detects that only the micro-service assigned ID “1” can be used to perform request data processing function PF 1 , and uses said micro-service at step S 602 , executing, by issuing a call to the micro-service via the registry  12 . The processing result is tabular data. 
     At step S 603 , the software execution controller  14  performs more composing, in order to perform PF 2 . The software execution controller  14  detects, based on information in the registry, that plural micro-services are available to summarize tabular data. Since the software execution controller  14  is in a manual composing mode, at step S 604 , a user is prompted for a selection from among the micro-services assigned ID “3” and “4”. For example, the user may be presented with the option to select one of them, a random selection, or all of them. 
     If the user makes a selection, then knowledge about the user decision is recorded in the knowledge base of the machine learning mechanism  16 . For example, such a record may identify the requested data processing function, values of characteristics of the input data (filename, filesize), and an indication of the user selection). In the case of a random selection or all of them, no preference from the user is recorded. 
     In the present example, the user chooses the micro-service assigned ID “4”, the preference is recorded, and at S 605 , the service is called by the software execution controller  14  and executed. The results are output by the micro-service. There may be an additional step in which the results are presented to the user, however, it may be that the user simply accesses a URL or URI at which the result is output. 
       FIG. 7  illustrates a flow of processing in a second worked example. The data processing request is a request for a summary of a large database. The machine learning mechanism  16  has had only a little training, for example, by virtue of the knowledge acquired in the first worked example. 
     The software execution controller, by reference to information in the registry  12 , identifies two requested data processing functions defined by the request (because there is no single function generating a summary from CSV input data). The requested data processing functions are PF 1 , “GET TABULAR DATA”, and PF 2 , “GET SUMMARY”. 
     At composing step S 701 , using the information stored in the registry  12  and knowledge of the data type of the input data specified in the data processing request, the software execution controller  14  detects that only the micro-service assigned ID “2” can be used, and at step S 702  uses said micro-service to perform PF 1  “GET TABULAR DATA”. 
     The software execution controller  14  proceeds to perform the composing for requested processing function PF 2 , “GET SUMMARY”. The software execution controller  14  is running in an automated composing mode, so when two micro-services are identified for summarizing tabular data (based on information in the registry  12 ), the user is not prompted for a selection. Instead, a request is issued to the machine learning mechanism  16  for a selection. 
     The software execution controller has only one relevant composing record for selecting between micro-service ID 3 and micro-service ID4, which is a user selection of ID 4. Therefore, the model for selecting a micro-service is trained to favor micro-service ID4 over micro-service ID3 in such a situation. At step S 703 , micro-service ID4 is selected by the machine learning mechanism  16  and executed under the control of the software execution controller  14 . However, micro-service ID4 is a micro-service intended to operate on data stored in local memory, and cannot produce a processing result from the large externally stored tabular data in the present worked example. The outcome of the execution is an “out of memory” error. 
     At step S 704  the software execution controller recovers from the error by adding a new micro-service to the execution schedule, choosing micro-service ID 3, calls micro-service ID 3 to execute at step S 705 , and returns the processing result. 
     For the third worked example, illustrated by  FIG. 8 , the data processing request is for the summary of a small database, in a situation in which the machine learning mechanism  16  has been extensively trained. 
     The software execution controller, by reference to information in the registry  12 , identifies two requested data processing functions defined by the request (because there is no single function generating a summary from CSV input data). The requested data processing functions are PF 1 , “GET TABULAR DATA”, and PF 2 , “GET SUMMARY”. 
     Using the information provide din the data processing request and the registry  12 , at step S 801  the software execution controller detects that only the micro-service assigned ID “2” can be used to perform PF 1 , and at step S 802  uses said micro-service to perform PF 1  “GET TABULAR DATA”. 
     The software execution controller  14  is set to compose in an automated mode, so that no reference to the user is required to select micro-services. For the sake of completeness, it is noted that, in addition to manual and automated composing modes, the software execution controller  14  may be set to a semi-automated composing mode, in which the user is prompted for a selection if the machine learning mechanism cannot achieve a predetermined degree of confidence in a selection. 
     Based on the type of data in the processing result from step S 802 , and the information in the registry  12 , the micro-services assigned IDs “3” and “4” are deemed suitable to perform PF 2 . At step S 803 , values of characteristics of the input data, in particular, a measurement of the amount of data, are acquired. The software execution controller  14  refers to the machine learning mechanism  16  to select between the two suitable micro-services. The model used by the machine learning mechanism  16 , which has been extensively trained, is aware that micro-service ID 4 successfully generates output data when a data size of input data is below a threshold, and times out when the data size of input data is above said threshold. Therefore, micro-service ID 4 is selected at step S 804 , and called to execute at step S 805 . Again the results are returned, and the usual recording of the performance statistics is performed. 
     When a new micro-service is added, for example to generate tabular data from tables in HTML, it is added to the capabilities of the system and records about its use are collected by the machine learning mechanism  16 . This happens in a way that is transparent to the user of the system, the developers of the micro-services, and the micro-services themselves, that transfer the data without making considerations about the destination, as these considerations are made by the machine learning mechanism  16 . 
       FIG. 9  is a block diagram of a computing device, such as a web server, which may be an embodiment, and which may be used to implement a method of an embodiment of the software service execution method. The computing device comprises a processor  993 , and memory,  994 . Optionally, the computing device also includes a network interface  997  for communication with other computing devices, for example with other computing devices embodiments. 
     For example, an embodiment may be composed of a network of such computing devices. Optionally, the computing device also includes one or more input mechanisms such as keyboard and mouse  996 , and a display unit such as one or more monitors  995 . The components are connectable to one another via a bus  992 . 
     The memory  994  may include a computer-readable storage medium, which may refer to a single medium or multiple media (e.g., a centralized or distributed database and/or associated caches and servers) configured to store computer-executable instructions or have data structures stored thereon. Computer-executable instructions may include, for example, instructions and data accessible by and causing a general purpose computer, special purpose computer, or special purpose processing device (e.g., one or more processors) to perform one or more functions or operations. The term “computer-readable storage medium” includes non-transitory computer-readable storage media, Random Access Memory (RAM), Read-Only Memory (ROM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Compact Disc Read-Only Memory (CD-ROM) or other optical disk storage, magnetic disk storage or other magnetic storage devices, flash memory devices (e.g., solid state memory devices). 
     The processor  993  is configured to control the computing device and execute processing operations, for example executing code stored in the memory to implement the various different functions of the software service execution apparatus, method, program, and system, described here and in the claims. The memory  994  stores data being read and written by the processor  993 . As referred to herein, a processor may include one or more general-purpose processing devices such as a microprocessor, central processing unit, or the like. The processor may include a complex instruction set computing (CISC) microprocessor, reduced instruction set computing (RISC) microprocessor, very long instruction word (VLIW) microprocessor, or a processor implementing other instruction sets or processors implementing a combination of instruction sets. The processor may also include one or more special-purpose processing devices such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), a digital signal processor (DSP), network processor, or the like. In one or more embodiments, a processor is configured to execute instructions for performing the operations and steps discussed herein. 
     The display unit  997  may display a representation of data stored by the computing device and may also display a cursor and dialog boxes and screens enabling interaction between a user and the programs and data stored on the computing device. The input mechanisms  996  may enable a user to input data and instructions to the computing device. 
     The network interface (network I/F)  997  may be connected to a network, such as the Internet, and is connectable to other such computing devices via the network. The network I/F  997  may control data input/output from/to other apparatus via the network. Other peripheral devices such as microphone, speakers, printer, power supply unit, fan, case, scanner, trackerball etc may be included in the computing device. 
     The registry  12  of  FIGS. 1, 2 , &amp;  4 , may be a processor  993  (or plurality thereof) executing processing instructions (a program) stored on a memory  994  and exchanging data via a network I/F  997 . In particular, the processor  993  executes processing instructions to receive, via the network I/F, software service and in particular information relating to the functionality thereof, from software developers and/or a system administrator and to store a registry entry per software service, as in step S 302  of  FIG. 3  and step S 501  of  FIG. 5 . Furthermore, the processor  993  may execute processing instructions to transmit, via the network I/F  997  or otherwise, information from registry entries to the software execution controller  14  for composing and execution of execution schedules. 
     The software execution controller  14  of  FIGS. 1 &amp; 2  may be a processor  993  (or plurality thereof) executing processing instructions (a program) stored on a memory  994  and exchanging data via a network I/F  997 . In particular, the processor  993  executes processing instructions to receive, via the network I/F, a data processing request from a user (which may be a human user via a client machine, or a higher level software program) and to respond by composing and executing an execution schedule to fulfill the request, as in steps S 502  to S 505  of  FIG. 5 . Furthermore, the processor  993  may execute processing instructions to store records of the composing and execution on a connected storage unit (i.e. on a knowledge base of the machine learning mechanism  16 ) and/or to transmit, via the network I/F  997 , results of executing the execution schedule to the requesting client. 
     The machine learning mechanism  16  of  FIGS. 1 &amp; 2  may be a processor  993  (or plurality thereof) executing processing instructions (a program) stored on a memory  994  and exchanging data via a network I/F  997 . In particular, the processor  993  executes processing instructions to receive, via the network I/F or otherwise, records of composing and executing of execution schedules for storage in the knowledge base from the software execution controller  14 . Furthermore, the processor  993  executes processing instructions to receive, via the network I/F or otherwise, a request for a selection of a software service from among plural software services, to generate a selection from relevant records in the knowledge base, and to respond with a selection, as in step S 503  of  FIG. 5 . Furthermore, the processor  993  may execute processing instructions to store records of the knowledge base on a connected storage unit. 
     Methods may be carried out on a computing device such as that illustrated in  FIG. 9 , including the memory  994  which include a non-transitory computer readable storage media for storing the methods. Such a computing device need not have every component illustrated in  FIG. 9 , and may be composed of a subset of those components. A method may be carried out by a single computing device in communication with one or more data storage servers via a network. The computing device may be a data storage itself storing the processing results from executing the composed execution schedules. 
     A method may be carried out by a plurality of computing devices operating in cooperation with one another. One or more of the plurality of computing devices may be a data storage server storing at least a portion of the registry  12 , the software library  20 , the knowledge base of the machine learning mechanism  16 , and/or processing results from executing the composed execution schedules. 
     Although a few embodiments have been shown and described, it would be appreciated by those skilled in the art that changes may be made in these embodiments without departing from the principles and spirit thereof, the scope of which is defined in the claims and their equivalents.