Abstract: Various aspects of the disclosure relate to bi-directional hybrid-feedback driven self-healing and self-scaling language transpiler system may include bi-directional hopping to support multi language transpilation, automatic conversion of a mapping into a transformation specification, a hybrid feedback mechanism to update the transformation mappings, automatic scaling and/or creation of enterprise wide mapping and token (e.g., grammar) vocabulary, and/or a self-healing and/or corrective translation capability to perform automatic correction of any partial transpilations over time from a learned mapping.

Abstract: A method includes configuring one or more permissions for a first page of memory including a first section of a plurality of sections of an executable program code to enable execution of the first section. The method also includes configuring one or more permissions for a second page of the memory including a second section of the executable program code to disable execution of the second section. The method also includes identifying one or more annotations in the executable program code, wherein the one or more annotations indicate one or more allowed transitions and one or more disallowed transitions between the plurality of sections. The method also includes changing, in view of the one or more annotations, the one or more permissions of the second page to enable execution of the second section of the executable program code.

Abstract: Techniques and solutions are provided for identifying sets of related data, such as for a data deletion process. Data objects can be considered as having parent-child relationships, where values for one or more attributes of a child data object are constrained by corresponding one or more attributes of a parent data object. The set of data objects and their relationships can be represented, such as in a graph. In an iterative process, the data object representation is analyzed to identify “leaf nodes,” which are data objects that do not constrain other data objects. Relevant data is deleted from the data objects, and the representation is updated to “remove” such data objects so that a new set of leaf nodes is obtained. Optionally, when a leaf node that serves as a parent is analyzed, it can be confirmed whether corresponding data has already been deleted from its children.

Abstract: A system receives source code for analysis. The system identifies external references to reference code in source code. The reference code is not included in the source code received for analysis. The system generates code stubs corresponding to the external references. Each code stub describes a semantic context for the corresponding external reference. The system provides the set of source code and the one or more code stubs for analysis of the code, for example, using a code analysis tool.

Abstract: A context-based recommendation system for feature search automatically identifies features of a feature-rich system (e.g., an application) based on the program code of the feature-rich system and additional data corresponding to the feature-rich system. A code workflow graph describing workflows in the program code is generated. Various data corresponding to the feature-rich system, such as help data, analytics data, social media data, and so forth is obtained. The code workflow graph and the data are analyzed to identify sentences in the workflow. These sentences are used to a train machine learning system to generate one or more recommendations. In response to a user query, the machine learning system generates and outputs as recommendations workflows identified based on the user query.

Abstract: Methods and systems for improved indexing of non-standardized, custom smart contracts. The improved indexer identifies custom landmarks (e.g., portions of bytecode indicative of custom smart contract transactions or particular functions in those transactions) that are indicative of transactions involving custom smart contracts (as well as the various attributes of those custom smart contracts). The indexer does this by first collecting bytecode for a subset of known transactions involving the custom smart contracts. The indexer then compares the bytecode of the custom smart contracts in the subset to identify the landmarks or probabilities that portions of the bytecode correspond to landmarks. Once these landmarks are identified (or a probability of the landmark is above a certain threshold), the indexer may designate these as known landmarks. The indexer may then compare the portion of the bytecode corresponding to the known landmark to raw bytecode.

Abstract: A first intermediate representation of a first portion of a source code implementing an application and a second intermediate representation of a second portion of the source code is received by a processing device. The first intermediate representation and the second intermediate representation is merged, at run-time, into a merged intermediate representation, wherein the first intermediate representation includes a reference to a function in the second intermediate representation. An execution flow transfer instruction within the merged intermediate representation is identified based on a run-time value of a parameter of the application. The execution flow transfer instruction references the function. A set of executable instructions implementing the function is identified within the merged intermediate representation. The execution flow transfer instruction is replaced with a copy of the set of executable instructions implementing the function.

Abstract: A method for blocking external debugger application from analysing code of software program installed on computing device. The method including initializing software program including an application program and an internal debugger application. The software program, upon initialization thereof, instructs internal debugger application to load application program in internal debugger application. The internal debugger application is configured to utilize kernel resources of an operating system of the computing device.

Abstract: A method includes receiving source code of a program to be compiled and compiling the source code of the program. Compiling the source code includes identifying a first function in the source code of the program that is a candidate to be executed by a graphics processing unit (GPU), generating a first intermediate representation and a second intermediate representation for the first function, and inserting a second function in the program in place of the first function, wherein the second function is to select one of the first intermediate representation or the second intermediate representation to be executed. The method further includes providing a compiled program package including the second function, the first intermediate representation and the second intermediate representation.

Abstract: A method, apparatus, and a non-transitory computer-readable storage medium for generating heterogenous platform code. The method may obtain a neural network model. The neural network model may be programed to run on at least one platform. The method may also obtain an initial intermediate representation (IR) code by encoding the neural network model, and obtain a target IR code by adding decorations to the initial IR code based on a target platform. The method may also output an executable code optimized to run on the target platform by decoding the target IR code.

Abstract: Techniques for providing secure modification of manufacturer usage description (MUD) files based on device applications are provided. In one embodiment, a method for secure modification of MUD files may include obtaining a request for one or more applications from a device. The method also includes providing to the device the one or more applications and a certification that includes an updated MUD identifier determined based on the one or more applications requested. The updated MUD identifier is associated with a concatenated MUD file that comprises individual MUD file portions for each of the one or more applications requested. The device is configured to request an updated device identifier using the certification. The updated device identifier includes the updated MUD identifier that is associated with the concatenated MUD file.

Abstract: A system for generating executable code of a software program that is matched with an intermediate representation (IR) of a source code of the software program. The system comprises a processor adapted for adding one or more annotation entries, each for a location in the IR, to program data in the IR. An internal annotation entry is generated for an internal location in the IR that is not referenced by an IR symbol in the global IR symbol table of the IR. The processor is further adapted for compiling the IR to produce a binary object comprising the annotation entries, and providing the binary object to a linker or to a dynamic loader to update in an executable object an executable internal annotation entry associated with an internal annotation entry to reference a run-time location in the executable object.

Abstract: Shader source code performance prediction is described. In accordance with the described techniques, an update to shader source code for implementing a shader is received. A prediction of performance of the shader on a processing unit is generated based on the update to the shader source code. Feedback about the update is output. The feedback includes the prediction of performance of the shader. In one or more implementations, generating the prediction of performance of the shader includes compiling the shader source code with the update to generate a representation of the shader, inputting the representation of the shader to one or more machine learning models, and receiving the prediction of performance of the shader as an output from the one or more machine learning models.

Abstract: A block frequency of a block in an irreducible loop in computer code is statically determined. The statically determining includes splitting an incoming block mass among multiple loop headers of the irreducible loop to provide an initial mass for the block. A bottom-up traversal and a top-down traversal of a plurality of loops of the computer code including the irreducible loop are iteratively performed to update a mass of the block. The iteratively performing commences with propagating the initial mass of the block to one or more blocks of one or more loops of the plurality of loops and continues with propagating and updating masses of select blocks of the plurality of loops until a predefined point is reached providing a resulting mass for the block. The block frequency of the block is determined using the resulting mass and is to be used in processing associated with the computer code.

Abstract: The present disclosure relates to a system and a method of optimizing register allocation by a processor. The method comprising receiving an intermediate representation (IR) code of a source code and initializing single instruction multiple data (SIMD) width for the IR code. The method comprising analyzing each basic block of the IR code to classify determine one or more instructions of the IR code as vector instructions, wherein each basic block is one of LOAD, STORE and arithmetic logical and multiply (ALM) instructions. The method comprising dynamically setting the SIMD width for each of the vector instructions.

Abstract: A software development process may support a transition from unverifiable, legacy code to verifiable code that is provably correct by construction. A behavioral model may be developed for legacy software that includes various behavioral criteria. Then, source code implemented in a verifiable language may be verified using the behavioral model to perform verification. Once the source code is complete and verified, a new verified implementation may be compiled. The verified implementation may then be executed, along with the legacy software, to identify differences in behavior which are fed back into the behavioral model and subsequently into the new source code. This process may then be iterated with the verifiable code being deployable once behavioral differences are resolved.

Abstract: This disclosure provides a picture generation method, apparatus, electronic device and storage medium. The picture generation method includes: acquiring a plurality of content elements contained in a design of a target picture, the content elements having respective attribute information, in response to a drawing instruction, parsing the content elements to obtain one or more graphic elements for each of the plurality of content elements, each graphic element having an associated graphic parameter that corresponds to the attribute information of a respective content element, drawing the graphic elements according to the associated graphic parameters to obtain content element pictures for respective content elements, and combining the obtained content element pictures to generate the target picture.

Abstract: A compiler-implemented technique for performing a storage allocation is described. Computer code to be converted into machine instructions for execution on an integrated circuit device is received. The integrated circuit device includes a memory having a set of memory locations. Based on the computer code, a set of values that are to be stored on the integrated circuit device are determined. An interference graph that includes the set of values and a set of interferences is constructed. While traversing the interference graph, a set of memory location assignments are generated by assigning the set of values to the set of memory locations in accordance with one or more color selection schemes.

Abstract: A method of allocating variables to computer memory includes determining at compile time when each of the plurality of variables is live in a memory region and allocating a memory region to each variable wherein at least some variables are allocated at compile time to overlapping memory regions to be stored in those memory regions at runtime at non-overlapping times.

Abstract: An information conversion device has one of: a replication necessity analysis unit for specifying where an instruction referred by phi functions is present in one basic block and inserting a transfer instruction therein; an intra-loop constant analysis unit for specifying a closed path in which a phi function reference is circulated and inserting the transfer instruction therein; an inter-instruction dependency analysis unit for specifying where data dependency is present between instructions as a reference destination of the phi functions and inserting the transfer instruction therein; a same instruction reference analysis unit for specifying where the phi functions referring to a result of a same instruction before branching are present and inserting the transfer instruction therein; and a spill out validity analysis unit for storing a value present in a loop processing, loading the value after the loop processing ends, and deleting the transfer instruction.

Abstract: Described herein are embodiments for managing comments in a program code file. A system may select program code and compile it to an intermediary code. The system may compare the intermediary code to a library of intermediary code snippets associated with comments. Based on the comparison, a system may recognize the code to be obsolete. In some embodiments, a system may generate one or more recommendations to update a code. Based on received feedback regarding a recommendation, a system may accordingly update a code.

Abstract: Techniques to process a source code program include, by one or more processors, determining an analysis perspective is exhibited by one or more portions of the source code program based at least in part on processing the source code program and an analysis perspective definition collection. The techniques further include storing a mapping of the analysis perspective to event data that is generated by object code when executed by one or more processors of a target computing system, wherein the object code is associated with the one or more source code program portions that exhibit the analysis perspective.

Abstract: Systems, methods, and other embodiments associated with the valuation of software code abstractions are described. In one embodiment, the method includes generating a directed acyclic graph (DAG) comprising a vertex node, children nodes, and a plurality of edges, wherein the vertex node includes a software code abstraction. A DAG is generated for each vertex node associated with a software code abstraction. The directed acyclic graph is analyzed to determine inheritance of the software code abstraction from the vertex node to the children nodes. A weight having a numerical value is assigned to the edges located between the vertex node and the children nodes. The numerical values are parsed to determine a cumulative sum of all of the edges associated with a particular vertex node. The cumulative sums are compared to determine an impact of the software code abstraction associated with each of the vertex nodes.

Abstract: A system on a chip may include a plurality of data plane processor cores sharing a common instruction set architecture. At least one of the data plane processor cores is specialized to perform a particular function via extensions to the otherwise common instruction set architecture. Such systems on a chip may have reduced physical complexity, cost, and time-to-market, and may provide improvements in core utilization and reductions in system power consumption.

Abstract: Methods and systems describe providing a compilable machine code program from dynamic language code. First, the system receives a computer program consisting of code in a dynamic language. For each dynamic instruction within the code, the system: identifies all function calls within the code which may call the dynamic instruction; generates a super slice callgraph for all identified function calls for the dynamic instruction, including dependency relationships for instance variables and static variables within time constraints; and generates a set of slices for the dynamic instruction. The system then compiles and executes each slice to identify one or more values for each dynamic instruction. Next, the system updates the computer program such that each of at least a subset of the dynamic instructions is replaced with machine code instructions based on the corresponding values.

Abstract: System to design and/or update programs for the operator interface of machines and/or plants that comprises at least one first calculation device dedicated to the management of a machine and/or plant, which contains at least one application program to manage the human-machine interface (HMI) of the machine and/or plant, and a second calculation device to execute a software, or development environment, to create a project file, wherein on the first calculation device and on the second calculation device respective communication programs are installed, suitable to transfer the project to the first calculation device, where the application program for the management of the HMI interface displays the project by means of a suitable OPC UA standard information model, by means of which it is possible to make modifications to the project dynamically, without interrupting the execution of the human-machine interface program, and so that every modification to the project, and therefore to the human-machine interface pr

Abstract: A system and method to translate source code in a source language executable in a source computing system to a target language executable in a target computing system. Source code in the source language is parsed to generate a corresponding parse tree containing at least one tree node and at least one leaf. During traversal of the parse tree, at least one mutation script is applied. The mutation script directs at least one of: generating a stream expression comprising at least one token corresponding to values of the at least one node and the at least one leaf of the parse tree; and formulating at least one text output containing a text pattern specified in the mutation script and/or values of the at least one token. Source code in the target language is outputted based on the at least one text output.

Abstract: Technologies are provided for generating executable asset bundles using a plug-in module loaded in an integrated development environment (IDE). The IDE can be used to create and edit source code assets and three-dimensional (3D) model assets that can be compiled into an executable program. The plug-in module can be used to generate an executable asset bundle based on a subset of the source code assets. Optionally, the executable asset bundle can include a subset of the 3D model assets. The IDE can be used to generate an executable program based on the remaining source code assets and 3D model assets. The executable program and the executable asset bundle can be distributed separately. The executable program can be executed by a client computing device and used to load the executable asset bundle on the client device. Loading the executable asset bundle can comprise downloading it from a remote server.

Abstract: A natural language command from an operator is received. The command regards a task that a software system is to execute. A programming language in which to program the task is determined by analyzing a plurality of factors regarding the task and the software system. Code is output in the programming language that executes the task.

Abstract: A computer-implemented method comprising obtaining a first candidate test associated with a testable component, wherein the first candidate test comprises an input having an input value; generating a second candidate test associated with the testable component by performing a dynamic mutation-based fuzzing of the first candidate test, wherein the second candidate test is based on the first candidate test and comprises a modified input value for the input based on data generated during an execution of the first candidate test or domain knowledge associated with the testable component; and creating a test for the testable component based on the first candidate test or the second candidate test.

Abstract: A memory chip (e.g., DRAM) connecting a SoC and an accelerator chip (e.g., an AI accelerator chip). A system including the memory chip and the accelerator chip. The system can include the SoC. The memory chip can include first memory cells to store and provide computation input data (e.g., AI computation input data) received from the SoC to be used by the accelerator chip as computation input (e.g., AI computation input). The memory chip can include second memory cells to store and provide first computation output data (e.g., AI computation output data) received from the accelerator chip to be retrieved by the SoC or reused by the accelerator chip as computation input. The memory chip can also include third memory cells to store second computation output data (e.g., non-AI computation output data) related to non-AI tasks received from the SoC to be retrieved by the SoC for non-AI tasks.

Abstract: High-level synthesis implementation of data structures in hardware can include detecting, within a design and using computer hardware, a data structure and a compiler directive for the data structure. The design may be specified in a high-level programming language. Using the computer hardware and based on the compiler directive, a modified version of the design may be created by, at least in part, generating a modified version of the data structure based on the compiler directive. Using the computer hardware, a circuit design may be generated from the modified version of the design by creating, at least in part, a hardware memory architecture for the circuit design and mapping the modified version of the data structure onto the hardware memory architecture.

Abstract: The present disclosure relates to devices and methods for transforming program source code using a rematerialization operation. The devices and methods may identify at least one hot spot with high register pressure in a program source code for an application and identify a plurality of live variables within the at least one hot spot. The devices and methods may group the plurality of live variables by a basic block that has contained a define or single use of the plurality of live variables. The devices and methods may build a directed acyclic graph (DAG) for each basic block that has a grouped plurality of live variables. The devices and methods may save the DAG as a candidate instruction to move in the program source code and may generate transformed program source code for the application by moving the candidate instruction.

Abstract: A controller capable of preventing human mistakes by customizing checking contents upon operations of users to automatically perform customized checking appropriately is provided. A controller that controls an industrial machine includes: a receiving unit that receives a condition of a callback process associated with control of the industrial machine and an action corresponding to the condition; and a designated condition registering unit that registers the condition and the action received by the receiving unit as a callback process.

Abstract: In one form, a software system includes a first non-transitory computer readable medium storing a source code program, a second computer readable medium, and a compiler. The first non-transitory computer readable medium includes a first function having a return type greater than a native width of a target processor, and a second function that calls the first function and that conditionally branches based on comparing a returned value from the first function to an expected value, wherein the expected value has first and second portions that are not equal to zero and are not equal to each other. The compiler converts the source code program in the first non-transitory computer readable medium into a machine language program for storage in the second computer readable medium. The compiler optimizes the source code program by selectively combining a set of redundant machine language instructions into a smaller set of machine language instructions.

Abstract: Embodiments of the present disclosure relate to a method, a device, and a computer program product for generating program code. In one embodiment, a method for generating program code is disclosed, including: acquiring code configuration information that includes code function information indicating a target function and device configuration information of a target device; and generating program code based on the code configuration information, wherein when executed, the program code can cause the target device to implement the target function. Through the embodiments of the present disclosure, the diversity and flexibility of function implementation can be improved, and the workload of developing program code can be significantly reduced.

Abstract: A failure rate model modeling a failure rate of a training functionality deployment in a training set of functionality deployments is constructed. The failure rate model is configured to receive functionality deployment data and output a corresponding failure rate prediction. Using the failure rate model, a set of functionality deployment failure rates is predicted, a functionality deployment failure rate in the set of functionality deployment failure rates corresponding to an upcoming functionality deployment. Using the set of functionality deployment failure rates, a deployment sequence of the set of upcoming functionality deployments is constructed to minimize a predicted overall failure rate of the set of upcoming functionality deployments. The deployment of each functionality deployment in the set of upcoming functionality deployments is caused, the deployment comprising activating the upcoming functionality program code according to the deployment sequence.

Abstract: Techniques are provided herein for contextual embedding of features of operational logs or network traffic for anomaly detection based on sequence prediction. In an embodiment, a computer has a predictive recurrent neural network (RNN) that detects an anomalous network flow. In an embodiment, an RNN contextually transcodes sparse feature vectors that represent log messages into dense feature vectors that may be predictive or used to generate predictive vectors. In an embodiment, graph embedding improves feature embedding of log traces. In an embodiment, a computer detects and feature-encodes independent traces from related log messages. These techniques may detect malicious activity by anomaly analysis of context-aware feature embeddings of network packet flows, log messages, and/or log traces.

Abstract: Methods, apparatus, systems and articles of manufacture are disclosed to improve interprocess communication. An example apparatus to improve network transmission efficiency of a sending peer includes a metadata engine to identify a reference element of a composite to a receiving peer, an annotation engine to identify configuration information of the reference element, a deep copy engine to extract an active portion of the reference element based on the configuration information, and a client payload engine to transmit the active portion of the reference element in a binary data format associated with transmission metadata.

Abstract: Implementations of the present disclosure relate a method, system and computer program products that dynamically compile conditional statements. According to the method, a first number of times that a first conditional statement of a plurality of conditional statements has been satisfied during execution of the plurality of conditional statements for a time period is obtained, wherein the plurality of conditional statements are compiled in a first order during the execution. Based on the first number of times and the first order, a determination is made whether the plurality of conditional statements are to be reordered. In response to a determination that the plurality of conditional statements are to be reordered, a second order of the plurality of conditional statements is determined, wherein the second order being different from the first order. The plurality of conditional statements are then compiled in the second order.

Abstract: Methods, apparatus, systems and articles of manufacture are disclosed improve utilization of a heterogeneous system executing software. The disclosed methods, apparatus, systems and articles of manufacture include an apparatus comprising a variant manager to determine whether an algorithm is a candidate for sub-algorithmic partitioning (SAP) based on at least one of a first size of input data to the algorithm and a second size of output data from the algorithm; a partitioner to partition the algorithm into at least a first tile and a second tile; and a compiler to compile a first variant based on the first tile and a second variant based on the second tile into an executable file, the first variant to be executed on a first processing element of the heterogeneous system, the second variant to be executed on a second processing element of the heterogeneous system.

Abstract: Techniques are disclosed for reordering operations of a neural network to improve runtime efficiency. In some examples, a compiler receives a description of the neural network comprising a plurality of operations. The compiler may determine which execution engine of a plurality of execution engines is to perform each of the plurality of operations. The compiler may determine an order of performance associated with the plurality of operations. The compiler may identify a runtime inefficiency based on the order of performance and a hardware usage for each of the plurality of operations. An operation may be reordered to reduce the runtime inefficiency. Instructions may be compiled based on the plurality of operations, which include the reordered operation.

Abstract: Examples described herein generally relate to generating, from a listing of source code, a plurality of basic blocks for compiling into intermediate language, determining, for a first basic block of the plurality of basic blocks, first heuristics related to applying a first plurality of optimizations to the first basic block, determining, for a second basic block of the plurality of basic blocks, second heuristics related to applying a second plurality of optimizations to the second basic block, and applying, based on the first heuristics and the second heuristics, one of the first plurality of optimizations to the first basic block to schedule first instructions for the first basic block and one of the second plurality of optimizations to the second basic block to schedule second instructions for the second basic block.

Abstract: Methods, apparatus, systems and articles of manufacture are disclosed for runtime scheduling of software executing on a heterogeneous system. An example apparatus includes in response to a variant compiler to generate a representation of an algorithm in a domain-specific language (DSL), a compilation auto-scheduler to generate a schedule based on configurations for processing elements of the heterogeneous system, the processing elements including at least a first and a second processing element, the variant compiler to compile variant binaries based on the schedule, each of the variant binaries associated with the algorithm in the DSL, the variant binaries including a first variant binary corresponding to the first processing element and a second variant binary corresponding to the second processing element, and an application compiler to generate a fat binary including a runtime scheduler to select one or more of the variant binaries to execute a workload based on the schedule.

Abstract: A computer-implemented method for editing one or more properties of one or more model elements in a block diagram of a technical computing environment. The model elements include blocks and variables in blocks, wherein one or more properties are assigned to each model element. The technical computing environment has a model editor, a data definition tool and a code generator. A processor of a host computer opens a block diagram in the model editor, displays a list of model elements present in the block diagram, receives a selection of one or more model elements, highlights the selected model elements, receives an edit command to set a new value for a chosen property of the selected model elements, and sets the chosen property to the new value. A non-transitory computer readable medium and a computer system is also provided.

Abstract: Methods and devices for generating program code representations may include receiving program code or edited program code for an application executing on the computer device. The methods and devices may include receiving an identification of a selected pipeline from a plurality of pipelines that defines a plurality of passes of actions to execute on the program code or the edited program code to optimize the program code or the edited program code. The methods and devices may include running the selected pipeline and generate optimizer output with a program code representation of the program code.

Abstract: A method may include generating, by performing a full analysis of code and for each component of the code, summaries including: a forward summary including a forward flow, and a backward summary including a backward flow, obtaining a modification to a modified component, determining that one of the summaries for the modified component is invalid, and in response to determining that a summary for the modified component is invalid: obtaining the forward flow from the forward summary of the modified component, obtaining the backward flow from the backward summary of the modified component, generating a local flow by performing an incremental analysis of the modified component using the forward flow of the modified component and the backward flow of the modified component, and detecting a defect in the code using the forward flow of the modified component, the local flow, and the backward flow of the modified component.

Abstract: A reconverging control flow graph is generated by receiving an input control flow graph including a plurality of basic code blocks, determining an order of the basic code blocks, and traversing the input control flow graph. The input control flow graph is traversed by, for each basic code block B of the plurality of basic code blocks, according to the determined order of the basic code blocks, visiting the basic code block B prior to visiting a subsequent block C of the plurality of basic code blocks, and based on determining that the basic code block B has a prior block A and that the prior block A has an open edge AC to the subsequent block C, in the reconverging control flow graph, creating an edge AF between the prior block A and a flow block F1, and creating an edge FC between the flow block F1 and the subsequent block C.

Abstract: Disclosed herein are representative embodiments of tools and techniques for installing, executing, and/or updating managed applications through generation of native code from code in an intermediate language. According to one exemplary technique, a computing device receives machine dependent intermediate language code (MDIL code) generated by an online provider for an application. Additionally, the computing device installs the application on the computing device by generating a native image for the application, which includes binding a portion of the MDIL code with one or more libraries on the computing device. Also, the native image is stored on the computing device for use in loading the application for execution.

Abstract: A software service execution system includes: a software library storing software services, each obtaining and processing input data from a specified input URI (uniform resource identifier) and outputting the result to a specified output URI; a metadata graph representing the software services, each being identifiable by a predicate defining a relationship between a subject vertex and an object vertex, the subject vertex storing the specified input URI and being linked by a directed edge labelled with the predicate to the object vertex storing the specified output URI; a metadata graph query interface receiving a query requesting a queried vertex, linked by a defined traversal path along one or more edges to a source vertex; a software service execution controller controlling the execution of the software services identified by specified predicates labelling edges on the defined traversal path, in an order determined by the defined traversal path.