Continuous integration and development of code in a secure environment

JP2023550607A5Active Publication Date: 2024-11-12GENENTECH INC
View PDF 0 Cites 0 Cited by

Patent Information

Application Number
JP2023526939
Authority / Receiving Office
JP · JP
Patent Type
Applications
Current Assignee / Owner
Priority Date
2020-11-10
Filing Date
2021-11-08
Publication Date
2024-11-12
Estimated Expiration
2041-11-08

AI Technical Summary

Technical Problem

The healthcare industry faces challenges in ensuring data integrity and privacy compliance in cloud-based continuous integration and deployment (CI/CD) systems due to unique regulatory requirements such as HIPAA and GDPR, which existing technologies struggle to address effectively.

Method used

A customized CI/CD system that classifies and validates source code based on specific regulatory requirements, performing static and dynamic analyses to ensure compliance with HIPAA, GDPR, and other regulations, and deploys code in secure containers.

Benefits of technology

Ensures efficient and secure deployment of healthcare software that meets regulatory standards, protecting data integrity and privacy while maintaining system performance and security.

✦ Generated by Eureka AI based on patent content.

Smart Images

  • Figure 00000000_0000_ABST
    Figure 00000000_0000_ABST
Patent Text Reader

Abstract

The present disclosure relates to techniques for continuous integration and continuous deployment of source code on a digital health platform. Specifically, aspects relate to receiving source code from a software development system (the source code has been verified according to a first QMS), generating a profile for the source code, classifying the source code into a class of code based on the profile, obtaining a second QMS associated with the class of code, verifying the source code according to the second QMS, and once the source code has been verified, running a build process to generate an executable program from the source code, encapsulating the executable program in a container, and deploying the container on one or more nodes of the software platform. The first QMS is adapted from the perspective of the software development system, while the second QMS is adapted from the perspective of the software platform.
Need to check novelty before this filing date? Find Prior Art

Description

Technical Field

[0001] Claim of Priority This application claims the benefit and priority of U.S. Provisional Patent Application No. 63 / 111,991, filed on November 10, 2020, the entire disclosure of which is incorporated herein by reference for all purposes.

[0002] Field

[0002] This disclosure relates to digital and personal healthcare, and more particularly, to techniques for continuous integration and continuous deployment of source code in a digital health platform.

Background Art

[0003] Background

[0003] Continuous integration (CI) is a software development methodology that tests the adaptation of code changes made by team members or developers to the underlying code of an application as they occur. CI accelerates the release process by detecting and fixing bugs early in the development cycle and promotes collaboration among developers. Continuous deployment (CD) is the process of providing new software builds to users as quickly as possible. This is the natural next step beyond CI and is an approach used to minimize the risks associated with software and new feature releases. Software development teams often focus on continuous development pipelines to rationalize processes in response to the increasing demand for rapid software releases, improved quality, and security. By adopting continuous integration and continuous deployment (CI / CD) methodologies, on-demand adaptation of software, time to market, test automation, security, and user satisfaction can be improved.

[0004]

[0004] In the healthcare sector, data-driven technology solutions are being developed to enable more personalized healthcare while reducing costs. The healthcare industry is shifting to on-demand deployment systems for personalized medical services and solutions, and healthcare providers are seeking help from developers to innovate solutions faster through the automation and streamlining of software development and service management processes. To support healthcare providers and services, developers are looking to distributed computing environments (e.g., cloud computing) as the standard for healthcare information technology infrastructure. This is gaining attention as a low-cost way to develop the complex infrastructure needed to support continuous development pipelines and deployments of software within service models (e.g., AaaS (Analytics as a Service)). While distributed computing environments like cloud computing offer many benefits to healthcare providers, they also present unique challenges regarding privacy and security due to their different functionality compared to traditional storage and information sharing solutions. For example, since users access data via internet connectivity, compliance with government regulations (e.g., Healthcare Portability and Accountability Act (HIPAA), Good Practices Quality Guidelines and Regulations (GxP), General Data Protection Regulation (GDPR)) is a unique challenge for healthcare providers considering cloud solutions to support their continuous software development pipelines and deployments. Therefore, there is a need for advancements in compliant software development platforms built to ensure the confidentiality, availability, and integrity of protected healthcare information. [Overview of the project]

[0005]

[0005] Various embodiments of computer implementation methods are provided. The method includes: receiving source code from a software development system in a continuous integration / continuous deployment (CI / CD) system, wherein the source code has already been verified in accordance with a first quality management system (QMS) associated with the software development system, and the first QMS defines a first set of requirements for verifying the source code; generating a source code profile by the CI / CD system, which includes identifying the characteristics of the source code and the characteristics of the data that the code operates on, and constructing a profile using the characteristics of the source code and the characteristics of the data that the source code operates on; and, based on the profile, the CI / CD system converts the source code into code Classifying into classes; obtaining a second QMS related to the class of code by the CI / CD system, wherein the second QMS defines a second set of requirements for verifying the class of code; verifying the source code by the CI / CD system in accordance with the second QMS, which includes performing code analysis to determine whether the source code conforms to or does not conform to the second set of requirements; once the source code is verified, running a build process by the CI / CD system to generate an executable program from the source code; encapsulating the executable program in a container by the CI / CD system; and deploying the container on one or more nodes of the software platform by the CI / CD system.

[0006]

[0006] In some embodiments, the software development system is located remotely from the CI / CD system via a network connection, and a first set of requirements differs from a second set of requirements, the first set of requirements being defined to determine whether the source code conforms to the intended use, operates as intended to perform the intended use, and meets basic security levels.

[0007]

[0007] In some embodiments, the characteristics of the source code are identified by analyzing source code comments and the scope of the source code, and the characteristics of the source code include one or more programming languages ​​used to write the source code, the intended use of the source code, and the environment in which the source code is intended to be executed, and the characteristics of the data on which the source code operates include the type and format of the data input to the source code, and the type and format of the data generated by the source code.

[0008]

[0008] In some embodiments, classification includes: querying a data structure that stores multiple profiles associated with various classes of code using the profiles; identifying a likely profile from the multiple profiles that has a predetermined number of characteristics that match the characteristics of the source code and the characteristics of the data on which the source code operates; and classifying the source code as a class of code associated with the likely profile.

[0009]

[0009] In some embodiments, classification includes using a classifier that takes a profile as input to generate an estimate of the class of code based on the characteristics of the source code and the characteristics of the data on which the source code operates.

[0010]

[0010] In some embodiments, a second set of requirements is defined to determine whether the source code behaves as intended to perform its intended use, whether it meets the required security level, whether it meets the requirements imposed by international, national, and / or regional regulations, whether it meets data privacy considerations, and whether it meets the performance requirements specific to the container or software platform environment.

[0011]

[0011] In some embodiments, the method further includes: configuring a first pipeline of tools by a CI / CD system to perform code analysis in accordance with a second QMS, wherein the code analysis includes static analysis, and configuring the first pipeline of tools includes: identifying a set of static analysis tools capable of analyzing source code to satisfy a set of requirements; determining a static testing protocol to run the set of static analysis tools to satisfy a second set of requirements; and provisioning the set of static analysis tools within the first pipeline of tools in accordance with the static testing protocol.

[0012]

[0012] In some embodiments, the method further includes: configuring a second pipeline of tools by a CI / CD system to perform code analysis in accordance with a second QMS, wherein the code analysis includes dynamic analysis, and configuring the second pipeline of tools includes: identifying a set of dynamic analysis tools capable of analyzing source code to satisfy a second set of requirements; determining a dynamic test protocol that runs a set of static analysis tools to satisfy a second set of requirements; and provisioning a set of dynamic analysis tools within the second pipeline of tools in accordance with the dynamic test protocol.

[0013]

[0013] In some embodiments, static analysis determines errors, high-risk components, unexpected features, open-source features, security vulnerabilities, and version-to-version changes in the source code, while dynamic analysis determines basic features, localization features, performance metrics, and security vulnerabilities.

[0014]

[0014] In some embodiments, determining open-source features includes: identifying open-source features of source code by a CI / CD system; determining permissions or licenses associated with open-source features by a CI / CD system; and compiling permissions or licenses associated with open-source features into a data structure by a CI / CD system.

[0015]

[0015] In some embodiments, the method further includes: identifying a source code version based on static analysis by a CI / CD system; generating a new executable program version containing the identified source code based on the identified source code version by a CI / CD system; and launching and visualizing the new executable program version and / or managing the old executable program version containing the source code by a CI / CD system.

[0016]

[0016] In some embodiments, the method further includes creating one or more nodes on the software platform by a CI / CD system and deploying executable programs in containers.

[0017]

[0017] In some embodiments, the method further includes, when the source code is invalidated, providing the CI / CD system with a notification that the source code is invalid, the notification including information about one or more reasons for the source code being invalid.

[0018]

[0018] In some embodiments, a second set of requirements is defined taking into consideration that the intended use of the source code is within or as a medical device.

[0019]

[0019] Some embodiments of the present disclosure include a system comprising one or more data processors. In some embodiments, the system includes a non-temporary computer-readable storage medium containing instructions such that, when the instructions are executed on one or more data processors, the one or more data processors cause one or more data processors to execute some or all of the methods and / or some or all of the processes disclosed herein. Some embodiments of the present disclosure include a computer program product tangibly embodied in a non-temporary machine-readable storage medium containing instructions configured to cause one or more data processors to execute some or all of the methods and / or some or all of the processes disclosed herein.

[0020]

[0020] The terms and expressions used are for illustrative purposes only, not limitation, and in using such terms and expressions there is no intention to exclude any equivalents or parts thereof of the features shown and described, however it should be recognized that various modifications are possible within the scope of the invention as described in the claims. Accordingly, although the invention as described in the claims is specifically disclosed by embodiments and optional features, modifications and variations of the concepts disclosed herein may be relied upon by those skilled in the art, and it should be understood that such modifications and variations are considered to be within the scope of the invention as defined by the appended claims.

[0021]

[0021] This disclosure will be explained in conjunction with the following attached drawings. [Brief explanation of the drawing]

[0022] [Figure 1] This diagram illustrates a digital health platform that provides data-driven technology solutions in various embodiments. [Figure 2] Illustrate CI / CD systems according to various embodiments. [Figure 3] Show a swimlane diagram illustrating the process of code integration, development, and deployment in a digital health platform according to various embodiments. [Figure 4] Show a flowchart of the process of code integration, development, and deployment according to various embodiments. [Figure 5] Show an exemplary pipeline of a specified tool and a static test protocol for executing the tool according to various embodiments. [Figure 6] Show an exemplary pipeline of a specified tool and a dynamic test protocol for executing the tool according to various embodiments. **BEST MODE FOR CARRYING OUT THE INVENTION**

[0023]

[0028] In the accompanying drawings, like components and / or features can have the same reference labels. Further, various components of the same type can be distinguished by following the reference label with a dash and a second label that differentiates the like components. If only the first reference label is used herein, the description is applicable to any of the like components having the same first reference label, regardless of the second reference label.

[0024] I. Overview

[0029] This disclosure describes techniques for CI / CD of source code on a digital health platform. More specifically, embodiments of this disclosure provide techniques for validating and deploying various classes of code (e.g., software as a medical device) according to a quality management system that defines a set of requirements for validating the various classes of source code.

[0025]

[0030] A quality management system (QMS) is a set of interconnected or interacting elements, such as policies, objectives, procedures, processes, and resources, established individually or collectively to guide an organization. In the context of this disclosure, organizations engaged in data-driven technology solutions on a digital health platform should establish, implement, monitor, and maintain a QMS that helps ensure they meet the needs of consumers and other stakeholders within the statutory and regulatory requirements related to their software products, services, or systems. This includes code validation and verification to check that a software product, service, or system meets requirements and achieves its intended purpose.

[0026]

[0031] Requirements can be needs or expectations for a system or its software. Requirements reflect the explicit or implicit needs of consumers and can be market-based, contractual, or statutory requirements, as well as internal organizational requirements. Requirements can take many forms (e.g., design requirements, functional requirements, implementation requirements, interface requirements, performance requirements, physical requirements). Software requirements typically stem from system requirements concerning aspects of system functionality assigned to the software. Software requirements are usually described in functional terms and are defined, refined, and updated as the development project progresses.

[0027]

[0032] A specification is a document that describes requirements. A specification may refer to or include drawings, patterns, and other related documents, and typically indicates the means and criteria for verifying compliance with the requirements. There are various types of specifications, such as system requirements specifications, software requirements specifications, software design specifications, software test specifications, and software integration specifications. All of these documents establish "specified requirements" and are design outputs for various forms of validation.

[0028]

[0033] Software validation provides objective evidence that the design output at a particular phase of the software development lifecycle meets all the requirements specified for that phase. Software validation examines the consistency, completeness, and accuracy of the software under development and its supporting documentation, supporting subsequent conclusions that the software is validated. Software testing is one of many validation activities aimed at ensuring that the output of software development meets input requirements. Other validation activities include various static and dynamic analyses, code and documentation inspections, walkthroughs, and other techniques.

[0029]

[0034] Software validation is part of the design verification of a completed software product, service, or system, and involves verifying, through inspection and presentation of objective evidence, that the software specifications meet user needs and intended uses, and that specific requirements implemented through the software are consistently met. In practice, software validation activities may be performed both during and at the end of the software development lifecycle to ensure that all requirements are met. Because software is usually part of a larger hardware system, software validation typically includes evidence that all software requirements are accurately and completely implemented and traceable to system requirements. The conclusion that software is validated largely depends on comprehensive software testing, inspection, analysis, and other validation tasks performed at each stage of the software development lifecycle. Testing of the software product, service, or system functionality in a simulated usage environment, or testing at a user site, is typically included as a component of the overall design validation program for the software product, service, or system.

[0030]

[0035] The Software Development Lifecycle (SDLC) is a process used in the software industry to design, develop, and test high-quality software according to the requirements defined by the Quality Management System (QMS). One of the key tasks in the SDLC is the validation and verification of the software's source code. As used in this document, "source code" refers to any fully executable description of a software system. Therefore, it is interpreted to include the original software version written in various programming languages, machine code, or an executable graphical representation of the system. When considering data-driven technology solutions in regulated environments such as healthcare, a robust approach to risk-based SDLC code review requires clearly defined processes, the use of qualified infrastructure, appropriate software design and deployment, qualified personnel, and strict change and version control. With the increasing adoption of cloud-based applications and services, cloud computing solutions such as AaaS and Software as a Service (SaaS) offer many advantages, including improved cost-effectiveness, ease of deployment, and a flexible and scalable platform. However, ensuring data integrity and data privacy in cloud computing solutions requires regulated entities to proactively and informedly plan and maintain data control after implementation in data-driven technology solutions on the cloud provider's site. This includes incorporating proactive approaches for data integrity and data privacy into SDLC code reviews, which can be challenging as it often requires validating and verifying software source code not developed by the regulated entity. For example, a developer might create a false statement about the identity of a programming language to directly conceal its true identity and evade proper code scanning. Alternatively, a developer might change the file extension to indirectly conceal the true identity of the programming language and evade proper code scanning.

[0031]

[0036] To address these limitations and issues, the technology described in this disclosure for source code verification and deployment by regulated entities utilizes a customized approach to the SDLC. This technology is intended to decouple the developer portion of the SDLC (in some cases, a CI-based approach developed according to the developer's QMS) from the regulated entity portion of the SDLC (a customized CI / CD-based approach developed according to the regulated entity's own QMS). This allows the developer to iterate through their portion of the SDLC n times before finally releasing a single version of the source code, which is then fed into the regulated entity portion of the SDLC and customized to address challenges specific to the regulated entity's digital health platform, such as data integrity and data privacy. If the source code fails verification within the regulated entity portion of the SDLC, the developer is notified and can return to fix the problem that caused the verification failure and repeat their portion of the SDLC any number of additional times, with the ultimate goal of deploying the source code to the digital health platform.

[0032]

[0037] An exemplary embodiment of the present disclosure relates to a method, the method comprising receiving source code from a software development system in a CI / CD system, the source code having already been verified in accordance with a first QMS related to the software development system, the first QMS defining a first set of requirements for verifying the source code. The method further comprises generating a profile of the source code by the CI / CD system, which comprises identifying the characteristics of the source code and the data on which the code operates, and constructing a profile using the characteristics of the source code and the data on which the source code operates. The method further comprises classifying the source code into a class of code based on the profile by the CI / CD system, and obtaining a second QMS related to the class of code by the CI / CD system, the second QMS defining a second set of requirements for verifying the class of code. The method further comprises verifying the source code in accordance with the second QMS by the CI / CD system, which comprises performing a code analysis to determine whether the source code conforms to or does not conform to the second set of requirements. The method further includes, once the source code has been verified, having the CI / CD system execute a build process to generate an executable program from the source code, having the CI / CD system encapsulate the executable program in a container, and having the CI / CD system deploy the container on one or more nodes of the software platform.

[0033] II. Digital Health Platform

[0038] Figure 1 is a simplified diagram of a digital health platform 100 for providing data-driven technology solutions in various embodiments. In the illustrated embodiment, the digital health platform 100 includes client computing devices 105 connected to a cloud-based infrastructure 110 via a network(s) 115 including a network gateway 120 and a network mesh 125. The infrastructure 110 is adapted to run services or software applications in service pods 130 using resources provided by a cloud service provider 140 within a deployment ring 135, using various hardware and cloud infrastructure (e.g., private or on-premises cloud infrastructure and public cloud infrastructure). These services or software applications may be delivered to users of the client computing devices 105 as web-based or cloud services based on models such as AaaS or SaaS. Several providers offer cloud services, such as Amazon, Google, and Oracle. The term cloud services is generally used to refer to services made available to users on demand via communication networks such as the Internet, by a service provider's system (e.g., infrastructure 110), such as a government-regulated operator. Therefore, consumers can use cloud services provided by service providers without having to separately purchase licenses, support, or hardware and software resources to support the services. For example, a cloud service provider's system may host one or more programs, and users can use those programs on demand via the internet without having to purchase the infrastructure resources to run them. Cloud services are designed to provide easy and scalable access to applications, resources, and services.

[0034]

[0039] In one case, a user operating a client computing device 105 (e.g., a consumer of software or services) consumes software products, services, or systems provided by various components 145 of the infrastructure 110 using one or more client applications. In another example, a user operating a client computing device 105 (e.g., a developer) uploads source code for software products, services, or systems provided by various components 145 of the infrastructure 110 using one or more client applications. Component 145 includes software components that can be executed by one or more processors, hardware components, or combinations thereof. It should be understood that various different system configurations are possible and may differ from those illustrated for the digital health platform 100. Therefore, the embodiment shown in Figure 1 is an example of a distributed computing environment for implementing the digital health platform and is not intended to be limiting.

[0035]

[0040] Client computing devices 105 include various types of computing systems, such as portable handheld devices, general-purpose computers like personal computers and laptops, workstation computers, wearable devices, game systems, thin clients, various messaging devices, sensors and other sensing devices. These computing devices can run various types and versions of software applications and operating systems (e.g., Microsoft Windows®, Apple Macintosh®, UNIX® or UNIX-like operating systems, Linux or Linux-like operating systems, e.g., Google Chrome® OS), which include various mobile operating systems (e.g., Microsoft Windows Mobile®, iOS®, Windows Phone®, Android®, BlackBerry®, Palm OS®). Portable handheld devices may include mobile phones, smartphones (e.g., iPhone®), tablets (e.g., iPad®), personal digital assistants (PDAs), etc. Wearable devices may include Fitbit Versa™ smartwatches, virtual reality (VR) or augmented reality (AR) systems such as Magic Leap 1® and Oculus®, and other devices. Game systems may include various portable game consoles, internet-enabled game consoles (e.g., Microsoft Xbox® game consoles (with or without Kinect® gesture input device), Sony PlayStation® systems, various game systems provided by Nintendo®, etc.). Client device 105 can run various applications such as various internet-related apps and communication apps (e.g., email apps, short message service (SMS) apps), and can use various communication protocols.

[0036]

[0041] Network(s) 115 is any type of network known to those skilled in the art that can support data communication using any of the various available protocols, including but not limited to TCP / IP (Transmission Control Protocol / Internet Protocol), SNA (System Network Architecture), IPX (Internet Packet Switching), AppleTalk®, etc. For illustrative purposes only, Network(s) 115 could be a local area network (LAN), an Ethernet-based network, Token Ring, a wide area network (WAN), the Internet, a virtual network, a virtual private network (VPN), an intranet, an extranet, a public switched telephone network (PSTN), an infrared network, a wireless network (e.g., a network operating on the IEEE 1002.11 protocol suite, Bluetooth®, and / or any other wireless protocol) and any combination of these or other networks.

[0037]

[0042] The network gateway 120 is a network node that forms a secure pathway between two or more networks 115 operating on the same or different protocols. The network gateway 120 can provide network security using one or more of the following technologies: a firewall that monitors input and output network traffic, a virtual private network that provides a private and secure communication channel, security scanning that identifies security flaws in one or more networks, and an access manager for authentication and authorization services, etc. The network gateway 120 routes network traffic using a router and service connectors (e.g., using a service subscription business model) that manage access to various software products, services, or systems. The network mesh 125 is a local network topology in which infrastructure 110 (e.g., bridges, switches, and other infrastructure devices) connect directly, dynamically, and non-hierarchically to as many other nodes as possible and work together to efficiently route data between devices and nodes. The network mesh 125 manages connectivity using one or more technologies such as load balancing, product, service, or system discovery, network access, routing, and peering, traffic mirroring, etc. The network(s) 115, network gateway 120, and network mesh 125 work together to manage all data flowing in or out of the infrastructure 110.

[0038]

[0043] Component 145 includes one or more general-purpose computers, specialized server computers (including, for example, PC (personal computer) servers, application-specific servers, midrange servers, mainframe computers, rack-mount servers, etc.), server farms, server clusters, or any other suitable configuration and / or combination of computers or systems that operate individually or in combination to provide resources, data, services, or programs to client computing devices 105 via a network (one or more) 115. Component 145 may further include other computing architectures involving virtualization, such as one or more virtual machines running a virtual operating system, or one or more flexible pools of logical memory devices that can be virtualized to maintain virtual memory devices. In various embodiments, component 145 is adapted to run one or more services or software applications that provide the functions described in this disclosure.

[0039]

[0044] Component 145 also includes one or more data repositories. These data repositories may be used to store data and other information in various embodiments. For example, one or more data repositories may be used to store information for providing data-driven technology solutions such as Software-as-a-Medical Device (SAMD) and for storing information for verifying and deploying source code to implement said data-driven technology solutions. Data repositories may reside in various locations. For example, a data repository used by a component may be locally located on the component or it may be remotely from the component, communicating with the component via a network-based or dedicated connection. Data repositories can be of various types. In some embodiments, a data repository used by a component may be, for example, a database, which may be a centralized database, a distributed database, a NoSQL database, a relational database, etc. One or more of these databases may be adapted to enable saving, updating, and retrieving data to and from the database in response to SQL format commands. In some embodiments, one or more databases may be used by an application to store application data. The data repositories used by applications can be of various types, such as key-value store repositories, object store repositories, or general storage repositories supported by file systems.

[0040]

[0045] Component 145 also includes compute nodes, which are adapted to run one or more programs, such as services or software applications that provide the functionality described in this disclosure (e.g., services or software applications delivered as web-based or cloud services, or applications for implementing CI / CD systems). Each node is a representation of a single machine optionally implemented within a cluster of nodes. A single machine can be a physical machine (e.g., a server in a data center) or a virtual machine hosted on a cloud provider such as Amazon Web Services® (AWS) with a set of available CPU and RAM resources. In a cluster, nodes pool resources to form a more powerful machine. Once one or more programs are deployed to the cluster, the cluster intelligently handles the distribution of work to the individual nodes. If any node is added or removed, the cluster can distribute the work as needed. For one or more programs or infrastructure 110, it is not important which of the individual machines is actually running the code.

[0041]

[0046] One or more programs deployed on one or more clusters are packaged as containers. Containers are a widely accepted standard, allowing various images to be defined for deploying one or more programs on infrastructure 110. Containerization allows infrastructure 110 to create self-contained execution environments. Any program and all its dependencies can be bundled into a single file and shared on infrastructure 110. Container creation can be done programmatically, enabling a powerful, fully automated CI / CD pipeline used for code verification and deployment on infrastructure 110. Containers are wrapped in a higher-level structure known as pods 130. Containers within the same pod 130 can share the same resources and local network. In some cases, containers can communicate with other containers within the same pod 130 as if they were on the same machine, while maintaining a degree of isolation from others. Pods 130 are used as the unit of replication in infrastructure 110. If a program or resources become overloaded and a single pod 130 instance cannot handle the load, infrastructure 110 can be configured to deploy new replicas of pods 130 to the cluster as needed. Even when the load is not high, it may be beneficial to have multiple copies of pod 130 running at all times in the production system to enable load balancing and fault tolerance. One or more instances of pod 130 are provisioned on a cloud infrastructure system provided by one or more cloud service providers 140.

[0042]

[0047] A cloud infrastructure system provided by one or more cloud service providers 140 includes infrastructure resources used to facilitate the provision of one or more instances of pods 130 that support various cloud services provided by infrastructure 110. To facilitate the efficient use of these resources for provisioning one or more instances of pods 130, the resources may be bundled into sets of resources or resource modules (also called “placement rings 135”). Each resource module or placement ring 135 may contain a pre-integrated and optimized combination of one or more types of resources. In a particular example, different placement rings 135 may be pre-provisioned for different types of cloud services. For example, a first set of placement rings 135 may be provisioned for SAMD services, and a second set of placement rings 135 may be provisioned for data analytics services, which may contain a different combination of resources than the first set of placement rings 135. In some cloud services, resources allocated to provisioning services may be shared among services.

[0043]

[0048] The digital health platform 100 further includes one or more kernels 150. Each kernel 150 is adapted to run on each cloud infrastructure system provided by one or more cloud service providers 140. The kernel 150 is a cluster manager that provides resource allocation and isolation across distributed applications or frameworks throughout the digital health platform 100. The kernel 150 provides one or more programs with an application programming interface (API) for orchestrating services and software, including resource management and scheduling. The architecture of the kernel 150 includes agent nodes for executing tasks, a master node for submitting tasks to the agent nodes, a zookeeper for selecting and addressing the master node, and a framework that works with the master node to schedule tasks to the agent nodes.

[0044]

[0049] The Digital Health Platform 100 further includes the CI / CD System 155. The CI / CD System 155 is implemented within the cloud infrastructure system, enabling the Digital Health Platform 100 to frequently update, test, and deliver changes within the source code of software products, services, or systems. As detailed in this document, in healthcare, there are government regulations regarding data security (e.g., data integrity and data privacy) that software must comply with. The CI / CD System 155 allows these policy regulations to be incorporated into the code, enabling automatic tracking, verification, and reconfiguration of compliance. One example of SAMD is the inclusion of data storage locations, server access control, and activity logging in the source code, allowing user data to be protected and managed throughout the entire use of the software. In addition, encrypted and password-protected operations can also be incorporated during continuous integration. During continuous delivery, security and monitoring tools can be used to track user activity and detect errors that could lead to security threats.

[0045]

[0050] The CI / CD system 155 can also be used for provisioning machine learning models. While machine learning models are initially trained using datasets, over time, the model may drift or the data may change, necessitating an update. When a machine learning model runs within a software application, the code associated with that application can include triggers for when the machine learning model should be retrained. For example, the code can include instructions to retrain the machine learning model at predetermined time intervals, when new training data becomes available, or when it is determined that the machine learning model's performance falls below a threshold. Furthermore, software developers can explore variations in model architecture and hyperparameters in a test environment based on monitoring the machine learning model's performance in the production environment or on estimated improvements for model optimization. The CI / CD system 155 facilitates building, testing, and deployment to the production environment once it is determined that the machine learning model meets performance requirements.

[0046] III. CI / CD System

[0051] Figure 2 shows a schematic diagram of a CI / CD system 200 (e.g., CI / CD system 155 described in Figure 1) for validating and deploying various classes of code in various embodiments. In the illustrated embodiment, the CI / CD system 200 includes an actor 205, a CI component 210, and a CD component 215. The actor 205 may include service providers such as software developers, code reviewers, quality engineers, release managers, and / or government-regulated operators. The actor 205 uploads source code to the CI / CD system 200 for validation, verification, and deployment through one or more client devices (e.g., client device 105 described in Figure 1). As shown in the illustration, the actor 205 and the portion of the SDLC related to the actor 205 are physically separated from the portion of the SDLC related to regulated operators (CI component 210 and CD component 215). This allows actor 205 to iterate through its portion of the SDLC n times before finally releasing a single version of the source code, which is then fed into CI component 210 and CD component 215, where it is customized to address challenges specific to the regulated operator's digital health platform, such as data integrity and data privacy. If the source code fails validation within CI component 210 and CD component 215, actor 205 is notified, and actor 205 can return to fix the problem that caused the validation failure and iterate through its portion of the SDLC any number of additional times, with the ultimate goal of deploying the source code to a software platform (e.g., the government-regulated operator's digital health platform 100 described in Figure 1).

[0047]

[0052] CI Component 210 includes a documentation system 220 for maintaining various QMSs, code profiles, and code review records; a task management system 225 for orchestrating source code profiling and code review tasks; a code hosting platform 230 for version control and collaboration; and a code review system 235 for performing static analysis of source code. When submitting source code, Actor 205 constructs the source code as a unique set of code changes and then pushes that unique set of code changes to CI Component 210. According to various aspects of this disclosure, the source code uploaded to CI Component 210 is typically already validated according to a QMS related to a software development system (e.g., a third-party developer's software development system). The task management system 225 is adapted to automatically identify the class of source code uploaded to CI Component 210 so that CI Component 210 can efficiently and accurately validate and verify the source code. Specifically, the task management system 225 generates a source code profile to identify the classes of source code, identifies a QMS specifically configured for the identified classes of source code, and is adapted to configure an optimal set of code review tasks according to the set of requirements defined by the identified QMS for validating and validating the source code.

[0048]

[0053] It should be understood that there are many different types or classes of source code and software that can be released from actor 205 to the CI component 210 and CD component 215 of the software platform. Therefore, the task management system 225 is designed to validate and verify all different types or classes of source code and software released to the CI / CD system 200. Furthermore, the intentions of actor 205 are not always known to the software platform or may not be consistent with the intentions of the software platform. For example, some actors 205 may attempt to attack the software platform by uploading malicious code for purposes such as hijacking secure sessions, stealing data, exploiting sensitive personal data, obtaining user security authentication, or crashing the network or the software platform. For example, some actors 205 may create false statements about the identity of the source code to directly conceal the true identity of the source code and avoid proper code scanning. Alternatively, some actors 205 may change the file extension to indirectly conceal the true identity of the source code and avoid proper code scanning. Therefore, the task management system 225 is adapted to classify the received source code regardless of the actor's intent and identify a QMS that defines a set of requirements for validating the source code specific to that class of source code. The set of requirements can be defined to determine whether the source code: operates as intended to perform its intended use; meets enhanced security levels; meets requirements imposed by international, national, and / or regional regulations; meets data privacy considerations; and meets performance requirements specific to the container or software platform environment. The identified QMS enables the CI / CD system 200 to validate, verify, and deploy the source code in an efficient, effective, and secure manner.

[0049]

[0054] The task management system 225 retrieves the identified QMS from the document system 220 and transfers the identified QMS, the optimal set of code review tasks, and the source code to the code hosting platform 230. The code review system 235 then performs code validation according to the optimal set of code review tasks. The optimal set of code review tasks defines a set of tests to be performed on the source code. The code review system 235 includes static analysis tools to analyze the source code by performing the set of tests. Based on the results of the set of tests performed on the source code, the code review system 235 determines whether the source code conforms to or does not conform to a set of requirements. Subsequently, the code review system 235 determines the validity of the source code based on whether it conforms to or does not conform to the set of requirements. Once the compliance and / or validity of the source code is confirmed, the code hosting platform 230 releases the source code to the CD component 215 for code building and further testing (e.g., static analysis, dynamic analysis, and / or white sourcing). The release includes transferring the source code and, optionally, the optimal set of identified QMS and code review tasks to the code build tool or engine 240.

[0050]

[0055] The CD component 210 includes a code build tool or engine 240 for managing code builds, a code build system 245 for building code, a code review system 250 for static and dynamic analysis of source code, an artifact factory 255 for storing build artifacts, and a deployment manager 260 for encapsulating executable programs / artifacts in containers and deploying the container's executable programs / artifacts onto the software platform. The code build tool or engine 240 is adapted to automate the creation of software builds and associated processes. These processes include compiling computer source code into binary code, packaging the binary code, and running automated tests. The code build system 245 is adapted to perform full builds, which build from scratch, or incremental builds. In incremental builds, the build is performed based on changes in the project since the last build state, using the last build state internally maintained by the code build engine 240. A full build or incremental build includes fetching code from the code build engine 240 or code repository, compiling the code (including checking dependencies), running automated tests using the code review system 250, linking libraries, code, files, etc. as appropriate, and, after validation, building and saving the artifact (including saving the build log).

[0051]

[0056] The code review system 250 performs code validation according to an optimal set of code review tasks. This optimal set defines a set of tests to be performed on the source code (these tests may be the same or similar tests, different tests, or a combination thereof, as those performed on the source code before the build). The code review system 250 includes static and dynamic analysis tools to analyze the source code by performing these tests. Based on the results of the tests performed on the source code, the code review system 250 determines whether the source code conforms to or does not conform to a set of requirements. In some cases, the code review system 250 determines the validity of the source code based on its conformance to or non-conformance to the set of requirements. Once the source code conforms to and / or is validated, the code build system 245 constructs artifacts along with the developed software and stores them in the artifact factory 255. Artifacts are one of many types of tangible by-products generated during software development. Some artifacts (e.g., use cases, class diagrams, and other Unified Modeling Language (UML) models, requirements, and design documents) help describe the functionality, architecture, and design of the software. In certain cases, the source code compiled for testing is also included as an artifact because the executable file is required to perform the test plan.

[0052]

[0057] The deployment manager 260 uses one or more customized pre-built images to encapsulate or package software into one or more containers and wrap one or more containers into pods. The deployment manager 260 also creates nodes or clusters of nodes supported by a set of resources or resource modules (e.g., the deployment ring 135 described in Figure 1) within one or more distributed computing environments 265 (e.g., cloud computing). The deployment layer 260 launches pods on the nodes or clusters of nodes, directly or indirectly (through one or more deployment abstraction layers). The deployment layer monitors the pods, determines the number of replicas of the pods running on the nodes or clusters of nodes, and adapts to add / replace pods as needed. The deployment manager 260 registers the software or services supported by the software (e.g., publishes the software or services) and establishes secure communication channels for users to access the software or services.

[0053] IV. Technologies for CI / CD of source code on a digital health platform

[0058] Figures 3-4 illustrate the processes and operations for source code verification and deployment. Note that individual embodiments may be described as processes shown as flowcharts, flow diagrams, data flow diagrams, structure diagrams, or block diagrams. While flowcharts describe operations as sequential processes, many operations may be performed in parallel or simultaneously. Furthermore, the order of operations may be rearranged. A process terminates when its operations are complete, but it may have additional steps not shown in the diagram. A process can correspond to a method, function, procedure, subroutine, subprogram, etc. If a process corresponds to a function, its termination may correspond to the function returning to the calling function or main function.

[0054]

[0059] The processes shown in Figures 3-4 can be implemented in software (e.g., code, instructions, programs) executed by one or more processing units (e.g., processors, cores) of hardware or a combination thereof. The software may be stored in memory (e.g., memory devices, non-temporary computer-readable storage media). The specific processing steps in Figures 3-4 are not intended to be limiting. Other sequences of steps may be performed according to alternative embodiments. For example, in alternative embodiments, the steps outlined above may be performed in a different order. Furthermore, each individual step illustrated in Figures 3-4 may include multiple substeps that can be performed in various sequences as appropriate for each individual step. In addition, additional steps may be added or removed depending on the particular application. Those skilled in the art will recognize many variations, modifications, and substitutions.

[0055]

[0060] Figure 3 illustrates process 300 for validating and deploying source code on a software platform using a CI / CD system. The process shown in flowchart 300 is implemented using the architecture, systems, and technologies shown in Figures 1 and 2. In step 305, the release manager of the software development system creates a release of source code. The release constitutes a partial or full functional version of the source code or software that the release manager intends to build and deploy on the software platform. As illustrated, there may be multiple release managers associated with one or more software development systems (i.e., actors). Each release manager may create one or more releases of source code for build and deployment. The software development system releases the source code to the CI / CD system of the software platform (e.g., a government-regulated operator's digital health platform 100 as described in Figure 1) for validation, verification, and deployment.

[0056]

[0061] In step 310, the CI of the software development system associated with a given release manager retrieves the source code for deployment and executes the build process to construct an executable program. The build process is performed to convert the source code into a standalone form or artifact (e.g., an efficient executable program) that can be run on a computing device. The build process is a combination of several activities that differ depending on the programming language and operating system, but the basic concept will be the same. The source code and its artifacts are fetched from the repository, compiled while checking dependencies, automated tests are run to verify usability, files, libraries, and code are linked respectively, and if the tests are successful, the artifact representing the executable program is finalized and saved, and a build log is recorded.

[0057]

[0062] In step 315, the CI of the software development system tests and verifies the source code and executable program in accordance with the QMS of the software development system. For example, each software development system may establish a software lifecycle model for verifying software developed within a QMS framework appropriate to the release manager's products and organization. The QMS defines a set of requirements for verifying the source code. The set of requirements may be defined to determine, for example, whether the source code conforms to the intended use, operates as intended to perform the intended use, and meets basic security levels. For each of the software lifecycle activities, there are actionable tasks that support the conclusion that the software is verified. However, the tasks performed, the order of execution, and the iteration and timing of execution are determined by the specific software lifecycle model selected and the security risks associated with the software application as individually recognized by the software development system. Each task for verifying the software typically begins with a requirement; for example, for each function of the software, the actor should be able to provide requirements that describe that function. The actor should also have, for each requirement, a test plan to verify that the function works as required, and a record-keeping system to record evidence that the plan was executed and the test results.

[0058]

[0063] In step 320, the CI of the software development system checks the quality of the source code. Code quality checks include reliability (e.g., determining whether the code runs as intended with minimal defects), maintainability (e.g., adhering to a consistent structure / style, being easy to understand, being well-documented, etc.), and testability (e.g., how well the software supports validation / testing efforts). In step 325, a decision is made as to whether the source code and executable program are valid and / or of sufficient quality. If the source code and executable program are invalid (do not meet all or part of the QMS requirements) and / or of poor quality (as defined and measured by the software development system in accordance with the QMS), the CI of the software development system transfers the source code to the development team for correction of the source code defects and / or quality. In contrast, if the source code and executable program are valid (meeting all or part of the QMS requirements) and / or of good quality (as defined and measured by the software development system in accordance with the QMS), the CI of the software development system will extract the source code for release to the software platform.

[0059]

[0064] In step 330, the software platform's CI / CD system receives the source code and automatically identifies the QMS used for validating, verifying, and deploying the source code. For example, the entity controlling the software development system and the relevant parts of the SDLC are separated from the entity controlling the CI / CD system and the relevant parts of the SDLC. As a result, the entity controlling the software development system can perform n iterations of their part of the SDLC (e.g., steps 305-320) to finally release a single version of the source code, which is received in step 330. This physical separation between the software development system and the CI / CD system allows the CI / CD system to be customized to address software platform-specific challenges such as data integrity and data privacy, while also providing an additional layer of privacy and security between the software development system and the CI / CD system.

[0060]

[0065] In some cases, the entity controlling the CI / CD system may be the same as or different from the entity controlling the software development system. In either case, the source code has already been validated according to the software development system's QMS. However, it should be understood that there are many different types or classes of source code and software that can be released to the software platform from various software development systems. For example, one software development system may be developing SAMD, another developing machine learning models for image processing, yet another developing software to be implemented in medical devices, and yet another developing software used for verifying medical devices or SAMD, etc. Therefore, the software platform's QMS is designed to validate and verify all different types or classes of source code and software released to the CI / CD system.

[0061]

[0066] Furthermore, the intentions of actor 205 are not always known to the software platform or may not align with the software platform's intentions. For example, some actors 205 may attempt to attack the software platform by uploading malicious code for purposes such as hijacking secure sessions, stealing data, exploiting sensitive personal data, obtaining user security authentication, or crashing the network or software platform. For example, some actors 205 may create false statements about the source code's identity to directly conceal the true identity of the source code and evade proper code scanning. Alternatively, some actors 205 may change the file extension to indirectly conceal the true identity of the source code and evade proper code scanning. Therefore, the CI / CD system should be adapted to classify the incoming source code regardless of the actor's intentions and identify a QMS that defines a set of requirements for verifying the source code specific to that class of source code. A set of requirements can be defined to determine whether the source code: operates as intended to perform its intended use; meets enhanced security levels; meets requirements imposed by international, national, and / or regional regulations; meets data privacy considerations; and meets performance requirements specific to container and software platform environments. The identified QMS enables the CI / CD system to validate, verify, and deploy the source code in an efficient, effective, and secure manner.

[0062]

[0067] Once the QMS is identified, the software platform's CI / CD system performs quality and compliance checks on the source code. These checks include both the build process, which constructs the executable program, and the validation and verification of the source code and executable program. The build process, as described in 310, is performed to convert the source code into a standalone form or artifact (e.g., an efficient executable program) that can run on a computing device. Validation is performed to ensure that the source code or executable program is built according to the requirements; in other words, to ensure that the source code or executable program meets those specified requirements. Verification is performed to ensure that the source code or executable program actually meets the user's needs and that the specifications were correct in the first place; in other words, to demonstrate that the source code or executable program, when placed in the intended environment, meets additional requirements, including the specified needs. Performing quality and compliance checks involves several subprocesses, including test plan development, test plan execution, and test plan execution logging. The test plan for the source code is automatically developed by the CI / CD system in accordance with the QMS. For example, a CI / CD system is aware of all types of validation and verification tasks that it can perform, including static and dynamic analysis to test the functionality of the source code, and is aware of all the functional requirements that need to be evaluated for verification of the source code via the identified QMS. Therefore, the CI / CD system will develop a test plan that includes the tasks to be performed, the order in which the tasks will be performed, the iterations and timing of the task execution, and a pipeline of tools for testing the functionality of the source code.

[0063]

[0068] The test plan is executed by the CI / CD system using an automated code review tool pipeline. Generally, the tools can be classified into two groups based on the type of analysis performed: dynamic analysis and static analysis. Dynamic analysis is performed on the executable code of the compiled program and checks only user-specific behavior; that is, only the code executed during testing (e.g., object code) is checked. Dynamic analyzers can provide users with information about memory leaks, program performance, call stacks, etc. Static analysis allows checking the program code (e.g., source code) before the tested program is executed. Compilers usually perform static analysis during the compilation process. However, in large-scale real-world projects, static analysis is often required throughout development to ensure that the source code meets additional requirements including reliability, maintainability, readability, testability, portability, and vulnerability. Many different analysis techniques are implemented in dynamic and static analyzers, such as Abstract Syntax Tree (AST) walker analysis, dataflow analysis, and path-sensitive dataflow analysis. These various analysis techniques will be organized and executed according to the test plan.

[0064]

[0069] Various analysis techniques are evaluated to determine the validity (quality, compliance, or non-compliance) of the source code against the requirements defined within the QMS. In other words, it is guaranteed that the source code or software meets those specified requirements. In some cases, the quality and compliance / non-compliance determination is an all-or-nothing decision, for example, the source code must meet all requirements to be considered to have adequate quality and compliance. In other cases, the compliance / non-compliance determination is flexible, for example, the source code must meet a certain percentage or threshold number of requirements to be considered to have adequate quality and compliance. If various analysis techniques demonstrate that the source code has adequate quality and compliance, the validity of the source code will be determined according to the requirements defined within the QMS (e.g., user needs, or that the specifications were correct in the first place). Conversely, if various analysis techniques demonstrate that the source code does not have sufficient quality and compliance, a notification may be sent to the actors and / or administrators of the software platform. This notification will identify the source code and the reasons for the validation failure. The execution and validation results of the test plan are recorded in a manner that maintains traceability between the functional requirements, the test plan for those functional requirements, and the evidence supporting that the test plan was executed. This record is maintained in a repository so that it can be used in the future, for example, to support reviews by government regulatory authorities.

[0065]

[0070] Various analytical techniques are evaluated, and the validity of the source code is determined according to the requirements defined within the QMS (e.g., user needs and the correctness of the specifications in the first place). In some cases, the validity determination is an all-or-nothing decision, for example, the source code must meet all requirements to be considered valid. In other cases, the compliance or non-compliance determination is flexible, for example, the source code must meet a certain percentage or threshold number of requirements to be considered valid. If various analytical techniques demonstrate that the source code is valid, the source code proceeds to block 320 for a white sourcing decision. Conversely, if various analytical techniques demonstrate that the source code is not valid, a notification may be sent to the actors and / or administrators of the software platform. This notification identifies the source code and the reason for the verification failure. The execution and verification results of the test plan are recorded in a manner that maintains traceability between the functional requirements, the test plan for the functional requirements, and the evidence supporting that the test plan was executed. This record is maintained in a repository so that it can be used in the future, for example, to support reviews by government regulatory authorities.

[0066]

[0071] The set of validation and verification requirements includes one or more of the following: to function as intended to perform the intended use; to meet requirements imposed by international, national, and / or regional regulations; to meet data integrity and privacy considerations; to meet performance requirements specific to container and software platform environments; and to meet enhanced security levels. The intended use requirement assesses whether the overall functionality of various features is performed as intended to implement the overall intended use of the source code or software (e.g., image processing for tumor detection). International, national, and / or regional regulatory requirements assess whether government regulations specific to the software platform (national security, cybersecurity, software malfunction, data privacy, etc.) are met. Where these regulatory requirements are, they depend on the international, national, and / or regional where the source code and / or the data used by the source code are deployed and used. Data integrity and privacy requirements assess whether protection from unauthorized access and data corruption is met. Where data integrity and privacy requirements are, they depend on the international, national, and / or regional where the source code and / or the data used by the source code are deployed and used. Performance requirements specific to container and software platforms assess whether asset and data isolation is met.

[0067]

[0072] Extended security level requirements assess whether security features are functioning to prevent or minimize vulnerability concerns specific to the software platform. For example, a software development system's QMS can define a baseline level of security that all of its source code or software must meet to address common vulnerabilities such as SQL injection, OS command vulnerabilities, buffer overflows, uncontrollable form strings, and integer overflows. However, a software platform's QMS can define an extended level of security that all source code or software deployed on the software platform must meet to address specific vulnerabilities unique to the software platform. For example, extended security levels may include requirements to maintain isolation between tenants, applications, clusters, etc., to prevent attackers from accessing assets or data from one application to another; requirements for complete and valid data deletion; requirements regarding API exposure; requirements for data recovery in the event of loss or theft of encryption keys; restrictions on insider abuse of authenticated access; and restrictions on the use of unauthenticated cloud services.

[0068]

[0073] In step 335, the CI / CD system performs white sourcing of source code. White sourcing identifies open-source components, including dependencies within the source code or software, and compiles these open-source components into data structures. In some cases, white sourcing further: (i) identifies permissions or licenses associated with the open-source components; (ii) identifies vulnerabilities arising from the open-source components (e.g., vulnerabilities arising from permissions or licenses associated with the open-source components); (iii) enforces the license policy through the SDLC; and (iv) compiles the permissions or licenses, vulnerabilities, and associated open-source components into data structures. In some cases, white sourcing prioritizes vulnerabilities based on whether the source code exploits them in order to stratify risk management.

[0069]

[0074] Step 340 determines whether the source code and executable program are valid and / or contain vulnerabilities caused by open-source components. If the source code and executable program are invalid (do not meet all or part of the QMS requirements) and / or contain vulnerabilities caused by open-source components (defined and determined by the software platform according to the QMS), the CI / CD system transfers the source code to the development team for them to fix the source code defects and / or vulnerabilities. On the other hand, if the source code and executable program are valid (meet all or part of the QMS requirements) and / or do not contain vulnerabilities caused by open-source components (defined and determined by the software platform according to the QMS), the CI / CD system proceeds to the software source code deployment process.

[0070]

[0075] In step 345, the CI / CD system implements version control and creates / stores artifacts in the artifact factory. Version control tracks all changes to the source code within the code repository. For example, a version control system will maintain a complete long-term change history for all files. This means all changes made by many individuals or actors during the lifespan of the source code or software. Changes include editing the contents of files, as well as creating and deleting them. A version control system can also branch and integrate multiple workflows related to the source code or software. Furthermore, a version control system can enable traceability of each change made to the source code or software, linking it to the actor along with annotations indicating the reason and intent behind the change, such as bugs or errors. Artifacts are created and stored in an artifact factory or universal repository. The artifact factory manages the end-to-end artifact lifecycle and provides consistency to the CI / CD system and workflow while supporting various source code and software package management systems. The artifact repository is the source of the artifacts required for the build process and the target to which the artifacts generated in the build process are deployed.

[0071]

[0076] In step 350, the executable program is encapsulated in a container and deployed as a pod instance on one or more nodes of the software platform. When the executable program is deployed, a deployment notification of the executable program's pod instance is provided to the CI / CD system. In block 355, the CI / CD system receives the pod instance deployment notification and forwards the notification to the release manager. In step 360, the process in the release manager loops back to allow the development team to fix source code defects and / or quality issues.

[0072]

[0077] Figure 4 illustrates process 400 for verifying and deploying source code on a software platform using a CI / CD system. The process shown in flow diagram 400 is implemented using the architecture, systems, and technologies shown in Figures 1 and 2. In step 405, the source code verified by the first QMS is accessed from the software development system. The source code is accessed from the CI / CD system of the software platform. In some cases, the software development system is located remotely from the CI / CD system via a network connection. The first QMS defines a set of requirements for verifying the source code. The first set of requirements is adapted to determine one or more of the following: whether the source code conforms to the intended use, whether it operates as intended to perform the intended use, and whether it meets basic security levels. The first QMS is customized to address the broad range of challenges faced by software developers in developing good source code, such as ensuring that software developers meet the needs of consumers and other stakeholders related to the software product, service, or system. This includes code validation and verification to check that a software product, service, or system meets a first set of requirements.

[0073]

[0078] In step 410, a profile of the source code is generated. The profile is generated by: (i) identifying the characteristics of the source code and the characteristics of the data that the code operates on; and (ii) constructing the profile using the characteristics of the source code and the characteristics of the data that the code operates on. The characteristics of the source code can be identified by analyzing the scope of source code comments on the source code and by analyzing the technology used by the code (e.g., Java or mobile platform). The characteristics of the source code may include one or more programming languages ​​used to write the source code, the intended use of the source code, the environment in which the source code is intended to be executed, and the environment in which the source code was developed (e.g., country of origin). The characteristics of the data that the source code operates on may include the type and format of the data input to the source code, and the type and format of the data generated by the source code. For example, the type and format may include whether the data is streaming data, model training data, integrity and privacy data, data compiled from SAMD, historical data, or archived data.

[0074]

[0079] In step 415, the source code is classified into a class of code based on profiles. Classification may involve querying a data structure that stores profiles associated with various classes of code using the profiles. A likely profile can be identified from profiles having a predetermined number of characteristics that match the characteristics of the source code and the characteristics of the data on which the source code operates. For example, a query may be used to identify a set of likely profiles from profiles having a predetermined number of characteristics that match the characteristics of the source code and the characteristics of the data on which the source code operates. The set of profiles may be sorted using one or more sorting characteristics, such as several matching characteristics, relevance values, and the strength of the matching values. Profiles at the top or bottom of the list of sets of profiles may be identified as likely profiles. The source code can be classified as a class of code associated with a likely profile. Alternatively, classification may use a classifier that takes profiles as input to generate an estimate of the class of code based on the characteristics of the source code and the characteristics of the data on which the source code operates. Advantageously, the classification processes in steps 410 and 415 allow for the verification and deployment of many different types or classes of source code and software. Furthermore, since the source code is classified regardless of the class assigned by the software developer / software development system, a second QMS is obtained for the code class classified in step 415, enabling the CI / CD system to validate, verify, and deploy the source code in an efficient, effective, and secure manner.

[0075]

[0080] In step 420, a second QMS is obtained for the class of code determined in step 515. The second QMS defines a second set of requirements for verifying the class of code. In some cases, the first set of requirements differs from the second set of requirements. The second set of requirements may include determining whether the source code: operates as intended to perform its intended use (e.g., in or as a medical device); meets enhanced security levels; meets requirements imposed by international, national, and / or regional regulations; meets data privacy considerations; and meets performance requirements specific to container or software platform environments. In specific cases, the second set of requirements is defined taking into account that the intended use of the source code is in or as a medical device. The second QMS is customized to address more specific challenges faced by software providers, such as government-regulated entities, when providing good quality source code, for example, to ensure that software providers meet the needs of consumers and other stakeholders within the legal and regulatory requirements related to their software products, services, or systems. This includes code validation and verification to check that the software product, service, or system meets a second set of requirements. This physical separation between the software development system and the CI / CD system allows for the customization of the CI / CD system and the second QMS to address specific challenges unique to such software platforms.

[0076]

[0081] In step 425, the first pipeline of the tools is configured to perform code analysis according to the second QMS. Code analysis includes static analysis. Configuring the first pipeline of the tools includes: (i) identifying a set of static analysis tools that can analyze the source code to satisfy the second set of requirements; (ii) determining a static testing protocol that will run the set of static analysis tools to satisfy the second set of requirements; and (iii) provisioning the set of static analysis tools within the tools of the first pipeline according to the static testing protocol. Figure 5 shows an example of the identified tool pipeline and a static testing protocol for running the tools. The static testing protocol defines parameters, the execution order of the set of static analysis tools, and criteria for determining whether the source code conforms to or does not conform to the second set of requirements. The static testing protocol includes first analyzing and detecting the programming language of the source code, and based on the detected programming language, performing one or more of the following: discovering code and comments, discovering blank lines, discovering unused code, discovering duplicate code, and comparing the code for differences. Subsequently, static testing includes performing one or more of the following: detecting errors in the code, determining the code's conformance to coding standards, detecting semantic and syntactic errors, and detecting domain-related coding errors. Then, the static testing protocol includes performing one or more of the following: identifying security vulnerabilities, detecting open-source components, and determining whether the code complies with various third-party regulations (e.g., government regulations such as HIPAA). Finally, the static testing protocol compiles the outputs of the various tools and generates metrics and reports to ultimately determine whether the source code has been verified according to the second QMS. The tools and static testing protocol shown in Figure 5 are merely examples, and it should be understood that any number and type of static analysis tools may be used, and various static testing protocols can be constructed to execute the tools and perform code analysis according to the second QMS.

[0077]

[0082] In step 430, the second pipeline of the tools is configured to perform code analysis according to the second QMS. Code analysis includes dynamic analysis. Configuring the second pipeline of the tools includes: (i) identifying a set of dynamic analysis tools that can analyze the source code to satisfy a second set of requirements; (ii) determining a dynamic test protocol that will run the set of dynamic analysis tools to satisfy the second set of requirements; and (iii) provisioning the set of dynamic analysis tools within the tools of the second pipeline according to the dynamic test protocol. Figure 6 shows an example of the identified tool pipeline and a dynamic test protocol for running the tools. The dynamic test protocol may define parameters, the execution order of the set of dynamic analysis tools, and criteria for determining whether the source code conforms to or does not conform to the second set of requirements. The dynamic test protocol first runs the code or executable program at runtime and, based on the execution, includes performing one or more of the following: function testing, critical function testing, function testing of specific features, compatibility and integration testing with other systems and / or localization, and regression analysis. Subsequently, dynamic testing includes performing one or more of the following: performance testing, load and stress testing, and volume and endurance testing. The dynamic testing protocol then includes identifying security vulnerabilities and determining the usability of the code or executable program. Finally, the dynamic testing protocol compiles the outputs of various tools and generates metrics and reports to ultimately determine whether the source code has been verified according to the second QMS. It should be understood that the tools and dynamic testing protocols shown in Figure 6 are merely illustrative, and any number and type of dynamic analysis tools may be used, and various dynamic testing protocols can be constructed to execute the tools and perform code analysis according to the second QMS.

[0078]

[0083] In step 435, the source code is validated according to the second QMS. Verification includes performing a code analysis to determine whether the source code conforms to or does not conform to the second set of requirements. The code analysis is evaluated to determine the validity (quality and conformance or non-conformance) of the source code against the second set of requirements defined within the second QMS. If the source code is demonstrated to have appropriate quality and conformance through various analysis techniques, the validity of the source code is determined. The code analysis is evaluated, and the validity of the source code is determined according to the second set of requirements defined within the second QMS (e.g., user needs and whether the specifications were correct in the first place).

[0079]

[0084] Code analysis may include static and / or dynamic analysis performed according to the first and / or second pipelines of the tools configured in steps 425 and 430, respectively. Static analysis may determine errors, high-risk components, unexpected features, open-source features, security vulnerabilities, and version-to-version changes in the source code. Dynamic analysis may determine basic features, localized features, performance metrics, and security vulnerabilities. In some cases, static analysis determines errors, high-risk components, unexpected features, open-source features, security vulnerabilities, and version-to-version changes in the source code. In some cases, dynamic analysis determines basic features, localized features, performance metrics, and security vulnerabilities. In some cases, determining open-source features includes performing a white-sourcing process. The white-sourcing process includes: (i) identifying open-source features in the source code; (ii) determining the permissions or licenses associated with the open-source features; and (iii) compiling the permissions or licenses and associated open-source features into data structures.

[0080]

[0085] If the source code is invalidated in step 440, an invalidation notification is provided to the software development system. The notification may include information about one or more reasons for the invalidation.

[0081]

[0086] In step 445, once the source code has been validated, the build process is executed to generate an executable program from the source code and to perform version control of the executable program. Version control may include identifying versions of the source code based on static analysis and generating versions of the executable program containing the source code based on the identified versions of the source code. Version control may further include launching and visualizing new executable program versions and / or managing older executable program versions containing the source code.

[0082]

[0087] In step 450, the executable program is deployed onto the software platform. The deployment includes: (i) encapsulating the executable program in a container, and (ii) deploying the container to one or more nodes of the software platform. In some cases, the deployment further includes creating one or more nodes on the software platform to host the executable program in the container. In some cases, the deployment further includes generating pod instances that wrap the container. The pod instances are deployed on one or more nodes of the software platform.

[0083] V. Additional Considerations

[0088] Some embodiments of this disclosure include a system comprising one or more data processors. In some embodiments, the system includes a non-temporary computer-readable storage medium containing instructions such that, when the instructions are executed on one or more data processors, the one or more data processors cause one or more data processors to execute some or all of the methods and / or some or all of the processes disclosed herein. Some embodiments of this disclosure include a computer program product tangibly embodied in a non-temporary machine-readable storage medium containing instructions configured to cause one or more data processors to execute some or all of the methods and / or some or all of the processes disclosed herein.

[0084]

[0089] The terms and expressions used are for illustrative purposes only, not limitation, and in using such terms and expressions, there is no intention to exclude any equivalents or parts thereof of the features shown and described, however it should be recognized that various modifications are possible within the scope of the invention described in the claims. Accordingly, although the invention described in the claims is specifically disclosed by embodiments and optional features, modifications and variations of the concepts disclosed herein may be relied upon by those skilled in the art, and it should be understood that such modifications and variations are considered to be within the scope of the invention as defined by the appended claims.

[0085]

[0090] The subsequent description provides only preferred exemplary embodiments and is not intended to limit the scope, applicability, or configuration of the Disclosure. Rather, the subsequent description of preferred exemplary embodiments provides a possible description for implementing various embodiments for those skilled in the art. It will be understood that various modifications can be made to the function and arrangement of the elements without departing from the spirit and scope set forth in the appended claims.

[0086]

[0091] Specific details are given in the following description to provide a complete understanding of the embodiments. However, it will be understood that embodiments can be carried out without these specific details. For example, circuits, systems, networks, processes, and other components may be shown as components in block diagram form so as not to obscure the embodiments with unnecessary detail. In other examples, well-known circuits, processes, algorithms, structures, and techniques may be shown without unnecessary detail to avoid obscuring the embodiments.

Claims

1. 1. A computer-implemented method comprising: In a continuous integration and continuous deployment (CI / CD) system, receiving source code from a software development system, the source code having been verified according to a first quality management system (QMS) associated with the software development system, the first QMS defining a first set of requirements for verifying the source code; generating a profile of source code by a CI / CD system, identifying characteristics of source code and characteristics of data operated on by said source code; constructing a profile using characteristics of the source code and characteristics of the data operated on by said source code; generating a profile of the source code, Classifying the source code into classes of code based on the profiles by the CI / CD system; acquiring, by the CI / CD system, a second QMS associated with the class of code, the second QMS defining a second set of requirements for verifying the class of code; verifying, by the CI / CD system, the source code in accordance with a second QMS, including performing code analysis to determine compliance or non-compliance of the source code with a second set of requirements; Once the source code is verified, executing a build process by the CI / CD system to generate an executable program from the source code; Encapsulating an executable program in a container by a CI / CD system; and Deploying the container on one or more nodes of the software platform by the CI / CD system. A method comprising:

2. a software development system located remotely from the CI / CD system via a network connection; The computer-implemented method of claim 1 , wherein the first set of requirements differs from the second set of requirements.

3. 2. The computer-implemented method of claim 1, wherein the first set of requirements is defined to determine whether the source code complies with the intended use, operates as intended to accomplish the intended use, and meets a basic level of security.

4. Characteristics of the source code are identified by analyzing source code comments and ranges of the source code; Characteristics of the source code include the programming language or languages ​​used to write the source code, the intended use of the source code, and the environment in which the source code is intended to run; 4. The computer-implemented method of claim 1, wherein the characteristics of the data on which the source code operates include the types and formats of data input to the source code and the types and formats of data generated by the source code.

5. To classify, using the profile to query a data structure that stores multiple profiles associated with different classes of code; identifying a likely profile from the plurality of profiles having a predetermined number of characteristics that match characteristics of the source code and characteristics of the data operated on by the source code; and classifying said source code into classes of code associated with likely profiles; The computer-implemented method of any one of claims 1 to 4, comprising:

6. 5. The computer-implemented method of claim 1, wherein classifying comprises using a classifier that takes the profile as input to generate an estimate of the class of the code based on characteristics of the source code and characteristics of the data on which the source code operates.

7. The computer-implemented method of any one of claims 1 to 6, wherein the second set of requirements is defined to determine whether the source code operates as intended to perform the intended use, meets an enhanced level of security, meets requirements imposed by international, national and / or local regulations, meets data privacy considerations, and meets performance requirements specific to container and software platform environments.

8. The method further includes configuring, by the CI / CD system, a first pipeline of tools and performing code analysis according to a second QMS, the code analysis including static analysis, and configuring the first pipeline of tools further comprises: Identifying a set of static analysis tools that can analyze source code to meet a set of requirements; determining a static testing protocol that executes a set of static analysis tools to meet a second set of requirements; and The computer-implemented method of any one of claims 1 to 7, comprising provisioning a set of static analysis tools in a first pipeline of tools according to a static testing protocol.

9. The method further includes configuring, by the CI / CD system, a second pipeline of tools and performing code analysis according to a second QMS, the code analysis including dynamic analysis, and configuring the second pipeline of tools further comprises: identifying a set of dynamic analysis tools capable of analyzing the source code to satisfy a second set of requirements; determining a dynamic testing protocol that executes a set of static analysis tools to meet a second set of requirements; and 10. The computer-implemented method of claim 8, further comprising provisioning a set of dynamic analysis tools in a second pipeline of tools in accordance with a dynamic testing protocol.

10. 10. The computer-implemented method of claim 8 or 9, wherein the static analysis determines errors, high-risk components, unexpected features, open source features, security vulnerabilities, and changes in source code from version to version, and the dynamic analysis determines basic features, localized features, performance metrics, and security vulnerabilities.

11. Deciding on open source features is Identifying open source features in source code through a CI / CD system; Determining, via the CI / CD system, any permissions or licenses associated with the open source features; and Compiling permissions or licenses associated with the open source features into a data structure by the CI / CD system. The computer-implemented method of claim 10, comprising:

12. Identifying, by a CI / CD system, a version of the source code based on static analysis; generating, by the CI / CD system, a new executable program version that includes the source code based on the identified version of the source code; and Launching and visualizing new executable program versions and / or managing older executable program versions including said source code through a CI / CD system The computer-implemented method of any one of claims 1 to 11, further comprising:

13. The computer-implemented method of any one of claims 1 to 11, further comprising creating, by the CI / CD system, one or more nodes on the software platform to host the executable programs in containers.

14. 14. The computer-implemented method of claim 1, further comprising, when the source code is invalid, providing, by the CI / CD system, a notification to the software development system that the source code is invalid, the notification including information regarding one or more reasons why the source code is invalid.

15. A computer-implemented method according to any one of claims 1 to 14, wherein the second set of requirements is defined having regard to the intended use of the source code being in or as a medical device.

16. One or more data processors of a continuous integration and continuous deployment (CI / CD) system; and Non-transitory computer-readable storage medium containing instructions wherein the instructions, when executed on the one or more data processors, cause the one or more data processors to: receiving source code from a software development system, the source code having been previously verified in accordance with a first quality management system (QMS) associated with the software development system, the first QMS defining a first set of requirements for verifying the source code; generating a profile of source code, identifying characteristics of source code and characteristics of data operated on by said source code; constructing a profile using characteristics of the source code and characteristics of the data operated on by said source code; generating a profile of the source code, Classifying source code into classes of code based on profiles; obtaining a second QMS associated with the class of code, the second QMS defining a second set of requirements for verifying the class of code; verifying the source code in accordance with a second QMS, the verifying source code including performing code analysis to determine compliance or non-compliance of the source code with a second set of requirements; Once the source code is verified, running a build process to generate an executable program from the source code; Encapsulating an executable program in a container; and Deploying the container on one or more nodes of the software platform A system that performs an operation including:

17. a software development system located remotely from the CI / CD system via a network connection; The system of claim 16 , wherein the first set of requirements is different from the second set of requirements.

18. 17. The system of claim 16, wherein the first set of requirements is defined to determine whether the source code complies with the intended use, operates as intended to accomplish the intended use, and meets a basic level of security.

19. Characteristics of the source code are identified by analyzing source code comments and ranges of the source code; Characteristics of the source code include the programming language or languages ​​used to write the source code, the intended use of the source code, and the environment in which the source code is intended to run; A system according to any one of claims 16 to 18, wherein the characteristics of the data on which the source code operates include the type and format of data input to the source code, and the type and format of data generated by the source code.

20. To classify, using the profile to query a data structure that stores multiple profiles associated with different classes of code; identifying a likely profile from the plurality of profiles having a predetermined number of characteristics that match characteristics of the source code and characteristics of the data operated on by the source code; and classifying said source code into classes of code associated with likely profiles; The system according to any one of claims 16 to 19, comprising:

21. 20. The system of claim 16, wherein classifying comprises using a classifier that takes the profile as input to generate an estimate of the class of code based on characteristics of the source code and characteristics of the data operated on by the source code.

22. The system of any one of claims 16 to 21, wherein the second set of requirements is defined to determine whether the source code operates as intended to perform the intended use, meets an enhanced level of security, meets requirements imposed by international, national and / or local regulations, meets data privacy considerations, and meets performance requirements specific to container and software platform environments.

23. The operation and configuring, by the CI / CD system, a first pipeline of tools and performing code analysis according to the second QMS, the code analysis including static analysis, and configuring the first pipeline of tools further comprising: Identifying a set of static analysis tools that can analyze source code to meet a set of requirements; determining a static testing protocol that executes a set of static analysis tools to meet a second set of requirements; and Provisioning a set of static analysis tools within a first pipeline of tools in accordance with a static testing protocol. The system according to any one of claims 16 to 22, comprising:

24. The operation and configuring, by the CI / CD system, a second pipeline of tools and performing code analysis according to a second QMS, the code analysis including dynamic analysis, and configuring the second pipeline of tools. identifying a set of dynamic analysis tools capable of analyzing the source code to satisfy a second set of requirements; determining a dynamic testing protocol that executes a set of static analysis tools to meet a second set of requirements; and Provisioning a set of dynamic analysis tools within a second pipeline of tools in accordance with a dynamic testing protocol.

24. The system of claim 23, comprising:

25. 25. The system of claim 23 or 24, wherein static analysis determines errors, high risk components, unexpected features, open source features, security vulnerabilities, and changes in source code from version to version, and dynamic analysis determines base functionality, localized features, performance metrics, and security vulnerabilities.

26. Deciding on open source features is Identifying open source features in source code through a CI / CD system; Determining, via the CI / CD system, any permissions or licenses associated with the open source features; and Compiling permissions or licenses associated with the open source features into a data structure by the CI / CD system.

26. The system of claim 25, comprising:

27. ​​The operation Identifying, by a CI / CD system, a version of the source code based on static analysis; generating, by the CI / CD system, a new executable program version that includes the source code based on the identified version of the source code; and Launching and visualizing new executable program versions and / or managing older executable program versions including said source code through a CI / CD system The system of any one of claims 16 to 26, further comprising:

28. A system as described in any one of claims 16 to 26, wherein the operations further include creating, by the CI / CD system, one or more nodes on the software platform to host executable programs in containers.

29. A system as described in any one of claims 16 to 28, wherein the operations further include, when the source code is invalid, providing a notification by the CI / CD system to the software development system that the source code is invalid, the notification including information regarding one or more reasons why the source code is invalid.

30. The system of any one of claims 16 to 29, wherein the second set of requirements is defined having regard to the intended use of the source code being in or as a medical device.

31. 1. A computer program product for causing one or more data processors of a continuous integration and continuous deployment (CI / CD) system to perform operations, the operations comprising: receiving source code from a software development system, the source code having been previously verified in accordance with a first quality management system (QMS) associated with the software development system, the first QMS defining a first set of requirements for verifying the source code; generating a profile of source code, identifying characteristics of source code and characteristics of data operated on by said source code; constructing a profile using characteristics of the source code and characteristics of the data operated on by said source code; generating a profile of the source code, Classifying source code into classes of code based on profiles; obtaining a second QMS associated with the class of code, the second QMS defining a second set of requirements for verifying the class of code; verifying the source code in accordance with a second QMS, the verifying source code including performing code analysis to determine compliance or non-compliance of the source code with a second set of requirements; Once the source code is verified, running a build process to generate an executable program from the source code; Encapsulating an executable program in a container; and Deploying the container on one or more nodes of the software platform A computer program comprising:

32. a software development system located remotely from the CI / CD system via a network connection; 32. The computer program product of claim 31, wherein the first set of requirements is different from the second set of requirements.

33. 32. The computer program product of claim 31 , wherein the first set of requirements is defined to determine whether the source code complies with the intended use, operates as intended to accomplish the intended use, and meets a basic level of security.

34. Characteristics of the source code are identified by analyzing source code comments and ranges of the source code; Characteristics of the source code include the programming language or languages ​​used to write the source code, the intended use of the source code, and the environment in which the source code is intended to run; A computer program as claimed in any one of claims 31 to 33, wherein the characteristics of the data on which the source code operates include the type and format of data input to the source code, and the type and format of data generated by the source code.

35. To classify, using the profile to query a data structure that stores multiple profiles associated with different classes of code; identifying a likely profile from the plurality of profiles having a predetermined number of characteristics that match characteristics of the source code and characteristics of the data operated on by the source code; and classifying said source code into classes of code associated with likely profiles; A computer program according to any one of claims 31 to 34, comprising:

36. 35. The computer program product of claim 31, wherein classifying comprises using a classifier that takes the profile as input to generate an estimate of the class of code based on characteristics of the source code and characteristics of the data on which the source code operates.

37. The computer program product of any one of claims 31 to 36, wherein the second set of requirements is defined to determine whether the source code operates as intended to perform the intended use, whether it meets an enhanced level of security, whether it meets requirements imposed by international, national and / or local regulations, whether it meets data privacy considerations, and whether it meets performance requirements specific to container and software platform environments.

38. The operation and configuring, by the CI / CD system, a first pipeline of tools and performing code analysis according to the second QMS, the code analysis including static analysis, and configuring the first pipeline of tools further comprising: Identifying a set of static analysis tools that can analyze source code to meet a set of requirements; determining a static testing protocol that executes a set of static analysis tools to meet a second set of requirements; and Provisioning a set of static analysis tools within a first pipeline of tools in accordance with a static testing protocol. A computer program according to any one of claims 31 to 37, comprising:

39. The operation and configuring, by the CI / CD system, a second pipeline of tools and performing code analysis according to a second QMS, the code analysis including dynamic analysis, and configuring the second pipeline of tools. identifying a set of dynamic analysis tools capable of analyzing the source code to satisfy a second set of requirements; determining a dynamic testing protocol that executes a set of static analysis tools to meet a second set of requirements; and Provisioning a set of dynamic analysis tools within a second pipeline of tools in accordance with a dynamic testing protocol.

39. The computer program of claim 38, comprising:

40. 40. The computer program product of claim 38 or 39, wherein static analysis determines errors, high risk components, unexpected features, open source features, security vulnerabilities, and changes in source code from version to version, and dynamic analysis determines base functionality, localized features, performance metrics, and security vulnerabilities.

41. Deciding on open source features is Identifying open source features in source code through a CI / CD system; Determining, via the CI / CD system, any permissions or licenses associated with the open source features; and Compiling permissions or licenses associated with the open source features into a data structure by the CI / CD system.

41. The computer program of claim 40, comprising:

42. The operation Identifying, by a CI / CD system, a version of the source code based on static analysis; generating, by the CI / CD system, a new executable program version that includes the source code based on the identified version of the source code; and Launching and visualizing new executable program versions and / or managing older executable program versions including said source code through a CI / CD system 42. The computer program of claim 31, further comprising:

43. The computer program product of claim 31, wherein the operations further include creating, by the CI / CD system, one or more nodes on the software platform to host the executable program in the container.

44. A computer program product as described in any one of claims 31 to 43, wherein the operations further include, if the source code is invalid, providing, by the CI / CD system, a notification to the software development system that the source code is invalid, the notification including information regarding one or more reasons why the source code is invalid.

45. A computer program according to any one of claims 31 to 44, wherein the second set of requirements is defined having regard to the intended use of the source code in or as a medical device.

46. A non-transitory machine-readable storage medium having recorded thereon a computer program according to any one of claims 31 to 45.