Visualizing Software Development

Abstract

To provide software development visualization.SOLUTION: Software development visualization is performed by reading a configuration file of a plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component depending upon the first software component, and generating a record of the plurality of software components, the record including dependency between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component.SELECTED DRAWING: Figure 1

Description

[Background technology]

[0001] Some products running dedicated software, such as products with many sensors or motors, implement their functionality through common computational components. The software for such products may not exist as a single program, but may be a web of interdependent software parts: programs, libraries, platforms, etc. Summary of the Invention

[0002] Aspects of the present disclosure are best understood from the following detailed description when read in conjunction with the accompanying drawings. It should be noted that, according to standard industry practice, various features have not been drawn to scale. In fact, the dimensions of various features may be arbitrarily increased or decreased for clarity of discussion. [Brief explanation of the drawings]

[0003] [Figure 1] FIG. 1 is a schematic diagram of a system for visualization of software development, in accordance with at least some embodiments of the present disclosure. [Figure 2] 1 is an operational flow for visualization of software development in accordance with at least some embodiments of the present disclosure. [Figure 3] 1 is an operational flow for building a software component in accordance with at least some embodiments of the present disclosure. [Figure 4] 1 is an operational flow for displaying a visual representation in accordance with at least some embodiments of the present disclosure. [Figure 5] 1 is a visual representation of a table format in accordance with at least some embodiments of the present disclosure. [Figure 6] 1 is a visual representation of a node format, according to at least some embodiments of the present disclosure. [Figure 7] 1 is a visual representation in a network format according to at least some embodiments of the present disclosure. [Figure 8] FIG. 1 is a block diagram of a hardware configuration for visualization of software development, in accordance with at least some embodiments of the present disclosure. DETAILED DESCRIPTION OF THE INVENTION

[0004] The following disclosure provides many different embodiments or examples for implementing different features of the provided subject matter. Specific examples of components, values, operations, materials, arrangements, etc. are described below to simplify the disclosure. These are, of course, merely examples and are not intended to be limiting. Other components, values, operations, materials, arrangements, etc. are contemplated. In addition, the disclosure may repeat reference numerals and / or letters in various examples. This repetition is for simplicity and clarity and does not, in itself, dictate a relationship between the various aspects and / or configurations discussed.

[0005] As a product having software-implemented functionality is developed, software components are modified, which affects other software components, such as those that depend on the modified software component. It is beneficial for individuals developing software components to be aware of the development of their dependencies. Records of such developments may be distributed across multiple repositories, each with different access rights. As the complexity of a product increases, the number of repositories may also increase. New dependencies, such as library dependencies used by functional components of a particular developer's software component, may not be known to the developer until the dependency repository is accessed. Accessing all repositories in the dependency chain ensures that the developer is aware of the dependencies.

[0006] In systems known to the inventors, various attribute information of each software component is determined, but when the construction of a software component fails, the developer encounters difficulties in determining which software component was the direct cause of the failure.

[0007] In at least some embodiments, development records of software components of a product are collected and assembled into a database. In at least some embodiments, dependency information for each software component is used to generate a view of the software web. In at least some embodiments, the status of a given software component is shown between software components that depend on it and software components that are depended upon by it. In at least some embodiments, all software components are mapped to a graph that shows dependencies as connections between the software components.

[0008] In at least some embodiments, a record of the construction of the software components is recorded in a database responsive to the construction of the software components. In at least some embodiments, the record indicates a construction status, dependencies between the software components, and an integration status. In at least some embodiments, a visual representation of the record displayable by a client device visually indicates dependencies between the first software component and the second software component, a construction status of the second software component, and an integration status of the first software component with respect to the second software component.

[0009] In at least some embodiments, assembling software component information into a single database alleviates the burden of checking each and every repository for such information. In at least some embodiments, the database stores historical information, allowing a snapshot of the status at a given point in time to be accessible. In at least some embodiments, information about the input software components or dependencies of each software component is collected to identify relationships between projects and their software components. In at least some embodiments, network views and node views are generated from the identified relationships, such as which libraries and other software components are utilized by each project. In at least some embodiments, the network view improves the node view by showing software components with no dependencies, which can be called “leaves.” In at least some embodiments, software components with no dependencies do not appear in the node view except through a specific search.

[0010] 1 is a schematic diagram of a system for visualizing software development in accordance with at least some embodiments of the present disclosure. The system includes a server 100, a repository 120, a database 122, and a client device 124.

[0011] Server 100 is in communication with repository 120, database 122, and client devices 124. Server 100 includes builder 110, record generator 112, and web interface 114. In at least some embodiments, server 100 is responsible for visualizing software development. In at least some embodiments, server 100 is configured to host builder 110, record generator 112, and web interface 114. In at least some embodiments, server 100 communicates with a database to store build records. In at least some embodiments, server 100 retrieves build records upon request. In at least some embodiments, server 100 communicates with client devices 124 to provide a web interface. In at least some embodiments, server 100 processes user requests. In at least some embodiments, server 100 is a physical server in a data center. In at least some embodiments, server 100 is a virtual server in a cloud environment. In at least some embodiments, server 100 runs an operating system such as Linux® or Windows Server®. In at least some embodiments, server 100 runs server software such as APACHE®, NGINX®, or NODE.JS®. In at least some embodiments, server 100 includes an operating system, server software, and applications. In at least some embodiments, the applications include builder 110, record generator 112, and web interface 114. In at least some embodiments, server 100 includes a firewall for security purposes. In at least some embodiments, server 100 includes a load balancer for handling traffic. In at least some embodiments, server 100 includes a database management system for communicating with database 122.

[0012] Builder 110 communicates with repository 120 and record generator 112. In at least some embodiments, builder 110 is configured to receive software component 121 from repository 120. In at least some embodiments, builder 110 is configured to read configuration file 111, build software component 121, and perform testing. In at least some embodiments, builder 110 is configured to send configuration file 111 to record generator 112 after building software component 121. In at least some embodiments, builder 110 is configured to perform version control. In at least some embodiments, builder 110 includes a build tool such as MAVEN®, GRADLE®, or NPM®. In at least some embodiments, builder 110 is configured to automate the build and test process. In at least some embodiments, builder 110 is configured to update the build status of software component 121 with a latest or previous (first, older) release tag based on the success of the build.

[0013] In at least some embodiments, configuration file 111 is configured to store details of software components 121, including dependencies and tests to be run. In at least some embodiments, configuration file 111 contains information for builder 110 to understand the build and test process. In at least some embodiments, configuration file 111 is a JSON file, an XML file, or the like. In at least some embodiments, configuration file 111 contains fields for software component names, dependencies, versions, and tests. In at least some embodiments, configuration file 111 indicates the version of each input software component used during the build.

[0014] Record generator 112 communicates with builder 110 and database 122. In at least some embodiments, record generator 112 is configured to generate records 113 of the build of software component 121, including dependencies, build status, and integration status. In at least some embodiments, record generator 112 is configured to parse configuration file 111 and generate records 113. In at least some embodiments, record generator 112 is configured to track the status of the build in a continuous integration system. In at least some embodiments, record generator 112 is configured to include the time of build of the software component in record 113.

[0015] In at least some embodiments, record 113 is configured to store build details, including dependencies, build status, and integration status. In at least some embodiments, record 113 is a column in a database table, a document in a NoSQL database, or the like. In at least some embodiments, record 113 includes fields for software component name, dependencies, build status, integration status, and build time. In at least some embodiments, record 113 includes integration status between a given software component and dependent software components.

[0016] Web interface 114 is in communication with client device 124. In at least some embodiments, web interface 114 is configured to allow a user to request and view records 113. In at least some embodiments, web interface 114 hosts scripts 115 that allow client device 124 to submit requests to database 122, receive records 113, and display information in records 113 for a user. In at least some embodiments, web interface 114 is a web application built with HTML, CSS, JavaScript, etc. In at least some embodiments, web interface 114 includes pages or views for requesting view records 113.

[0017] In at least some embodiments, script 115 is configured to provide instructions for displaying visual representations of records 113. In at least some embodiments, script 115 is executed by a web browser on client device 124. In at least some embodiments, script 115 is an HTML file, a JavaScript file, or the like. In at least some embodiments, script 115 includes instructions for functions or methods for creating visual representations and handling user interactions. In at least some embodiments, script 115 is configured with web page interactivity. In at least some embodiments, script 115 is HTML and includes instructions for switching visual representations in response to sorting of software components by interaction and dependency with a given software component.

[0018] Repository 120 is in communication with builder 110. In at least some embodiments, repository 120 is configured to store software parts 121. In at least some embodiments, repository 120 is accessed by builder 110 to retrieve software parts 121 for building. In at least some embodiments, repository 120 is a GIT® repository or a MAVEN® repository. In at least some embodiments, repository 120 includes a version history of software parts 121. In at least some embodiments, repository 120 is configured for software development, version control, and dependency management. In at least some embodiments, repository 120 stores multiple software parts, including software part 121.

[0019] In at least some embodiments, software parts 121 are individual components that are built and tested by builder 110. In at least some embodiments, software parts 121 are stored in repository 120 and read by builder 110. In at least some embodiments, software parts 121 include libraries, modules, services, etc. within a software project. In at least some embodiments, each software part includes a set of files and directories. In at least some embodiments, software parts 121 are useful in software development to modularize code and manage complexity.

[0020] In at least some embodiments, database 122 is configured to store build records 113, including dependencies, build status, and integration status. In at least some embodiments, database 122 is in communication with record generator 112. In at least some embodiments, database 122 receives records 113 from builder 110 and provides records 113 to client device 124 upon request. In at least some embodiments, database 122 includes MySQL®, PostgreSQL®, MongoDB®, or the like. In at least some embodiments, database 122 comprises tables or collections for storing build records, such as record 113. In at least some embodiments, database 122 is configured for persistent data storage.

[0021] Client device 124 is in communication with web interface 114 and database 122. In at least some embodiments, client device 124 is configured to execute script 115 to request and display records 113. In at least some embodiments, client device 124 sends requests to database 122 and receives records 113. In at least some embodiments, client device 124 executes script 115 to display visual representations. In at least some embodiments, client device 124 is a personal computer, smartphone, tablet, etc. In at least some embodiments, client device 124 includes a web browser for executing script 115 and displaying visual representations. In at least some embodiments, client device 124 is used to communicate with various web applications. In at least some embodiments, client device 124 is configured to allow user interaction to switch modes of visual representations and sort software components by dependency.

[0022] 2 is an operational flow for software development visualization in accordance with at least some embodiments of the present disclosure. In at least some embodiments, the operational flow provides a method for software development visualization in accordance with at least some embodiments of the present disclosure. In at least some embodiments, the method is performed by a controller of a server, such as controller 802 of server 800 in FIG. 8 described below.

[0023] At S230, the control unit builds the software components. In at least some embodiments, the control unit compiles and links the software components to create an executable file or library. In at least some embodiments, the control unit builds multiple software components, and the build status indicates a latest release tag in response to successfully building the multiple software components and an earlier (previous, older) release tag in response to unsuccessfully building the multiple software components. In at least some embodiments, the control unit fetches dependencies, compiles source code, links libraries, and packages the software build into a distributable format. In at least some embodiments, the control unit triggers automated testing to verify the correctness of the build. In at least some embodiments, the control unit verifies whether the source code for the software components is available and in a buildable state. In at least some embodiments, the control unit resolves dependencies. In at least some embodiments, the control unit sets up a build environment, such as a compiler and build script. In at least some embodiments, the control unit creates a working version of the software build for testing and deployment.

[0024] At S232, the control unit reads a configuration file. In at least some embodiments, the control unit reads a configuration file associated with a software component. In at least some embodiments, the control unit reads the configuration file for the multiple software components in response to building the multiple software components, the multiple software components including a first software component and a second software component, the second software component dependent on the first software component. In at least some embodiments, the control unit parses the configuration file. In at least some embodiments, the control unit processes errors or inconsistencies in the configuration file. In at least some embodiments, the control unit obtains information about the software components, including dependencies and versions of each input software component used during the build.

[0025] At S234, the control unit generates a record. In at least some embodiments, the control unit generates a record including dependencies between the software components, their build status, and their integration status. In at least some embodiments, the control unit generates a record of a plurality of software components, the record including dependencies between a first software component and a second software component, the build status of the plurality of software components, and the integration status between the first software component and the second software component. In at least some embodiments, the control unit creates a data structure to hold the record and serializes the data structure into a format suitable for sending to a database, such as an SQL insert statement or a JSON object.

[0026] At S235, the controller transmits the record to a database. In at least some embodiments, the controller transmits the record to a database for storage. In at least some embodiments, the controller transmits the record to the database. In at least some embodiments, the controller establishes a connection to the database, handles any connection errors, and ensures successful transmission of the record.

[0027] At S237, the controller provides a script. In at least some embodiments, the controller provides the script for displaying a visual representation of interdependencies between the software components. In at least some embodiments, the controller provides the script to the client device, the script including instructions for displaying a visual representation of interdependencies between the software components. In at least some embodiments, the controller provides the script to the client device. In at least some embodiments, the controller dynamically generates the script based on a current status of the client device.

[0028] At S238, the controller transmits the record from the database to the client device. In at least some embodiments, the controller retrieves the record from the database in response to the request and sends it to the client device. In at least some embodiments, the controller queries the database to retrieve the record, handles any query errors, and transmits the record to the client device over a network connection. In at least some embodiments, the controller establishes a direct connection between the client device and the database.

[0029] 3 is an operational flow for building a software component in accordance with at least some embodiments of the present disclosure. In at least some embodiments, the operational flow provides a method for building a software component in accordance with at least some embodiments of the present disclosure. In at least some embodiments, the method is performed by a controller of a server, such as controller 802 of server 800 in FIG. 8 , described below.

[0030] At S340, the controller receives build instructions. In at least some embodiments, the controller receives instructions for building the software component. In at least some embodiments, the controller initiates the build process in response to receiving the build instructions.

[0031] At S341, the control unit builds the software components. In at least some embodiments, the control unit reads a configuration file. In at least some embodiments, the control unit identifies dependencies. In at least some embodiments, the control unit builds the software components in a specified order. In at least some embodiments, the control unit builds the software components according to the dependencies and instructions in the configuration file.

[0032] In S343, the controller determines whether the build process was successful. In at least some embodiments, the controller updates the build status based on the success or failure of the build process. In at least some embodiments, in response to a successful build, the operational flow proceeds to pointing to a new release tag in S344. In at least some embodiments, in response to an unsuccessful build, the operational flow proceeds to pointing to a previous (older) release tag in S345.

[0033] At S344, the controller indicates the latest release tag. In at least some embodiments, in response to a successful build, the controller updates the build status to indicate the latest release tag. In at least some embodiments, the latest release tag indicates that the most recent build was successful.

[0034] At S345, the controller indicates a previous (earlier, older) release tag. In at least some embodiments, in response to the failed build, the controller updates the build status to indicate a previous (earlier, older) release tag. In at least some embodiments, the controller sends an error report or notification regarding the failed build.

[0035] At S347, the controller determines the tests. In at least some embodiments, the controller reads a configuration file to determine the tests to be run.

[0036] At S348, the controller executes the tests. In at least some embodiments, the controller executes the tests identified in S347. In at least some embodiments, the controller updates the integration status based on the test results. In at least some embodiments, the controller generates the test results. In at least some embodiments, the controller indicates the integration status as indicated as successful, failed, or not executed (not executed). In at least some embodiments, the functionality and compatibility of the constructed software components are verified.

[0037] 4 is an operational flow for displaying a visual representation in accordance with at least some embodiments of the present disclosure. In at least some embodiments, the operational flow provides a method for displaying a visual representation in accordance with at least some embodiments of the present disclosure. In at least some embodiments, the method is performed by a client device, such as client device 824 of FIG. 8 described below.

[0038] At S450, the client device receives the script. In at least some embodiments, the client device receives the script from the server. In at least some embodiments, the client device establishes a connection with the server. In at least some embodiments, the client device sends a request for the script. In at least some embodiments, the server processes the request. In at least some embodiments, the server sends the script to the client device. In at least some embodiments, the script includes instructions for a visual representation of the software component.

[0039] At S452, the client device retrieves the records. In at least some embodiments, the client device sends a request to a database to retrieve the records of the software part. In at least some embodiments, the database processes the request. In at least some embodiments, the database returns the records. In at least some embodiments, the client device receives the records.

[0040] At S454, the client device displays a visual element. In at least some embodiments, the client device interprets the script. In at least some embodiments, the client device generates a visual element for the software component based on the recording. In at least some embodiments, the client device renders the visual element on a display. In at least some embodiments, the client device is capable of rendering the visual element. In at least some embodiments, the visual element is one of a software component, a dependency, a build status, an integration status, etc.

[0041] At S456, the client device determines whether all visual elements have been displayed. In at least some embodiments, the client device checks whether all elements in the visual representation have been rendered. In response to determining that all visual elements have been displayed, operational flow proceeds to determining whether a user interaction has been received at S458. In response to determining that all visual elements have not been displayed, operational flow returns to displaying the visual elements at S454.

[0042] At S458, the client device determines whether there is a user interaction with the visual representation. In at least some embodiments, the user interaction is a click on a software component. In at least some embodiments, the user interaction is a request to sort the software components by dependency. In at least some embodiments, the client device processes the user interaction. In at least some embodiments, the visual representation is updated based on the user interaction. In response to determining that there is a user interaction with the visual representation, operational flow returns to displaying the visual elements at S454. In response to determining that there is no user interaction with the visual representation, operational flow ends.

[0043] 5 is a visual representation in a table format according to at least some embodiments of the present disclosure. The visual representation includes rows or columns for software part name 560, dependencies 562, build status 564, and integration status 566.

[0044] In at least some embodiments, each software component is represented by a row or column in the visual representation. In at least some embodiments, the rows and columns are divided into fields. In at least some embodiments, these fields correspond to the software component name, dependencies, build status, and integration status of the software component.

[0045] In at least some embodiments, the table format has sorting capabilities. In at least some embodiments, the table is sortable by dependency in response to user interaction. In at least some embodiments, the order of the rows or columns indicates the dependency between the software components. In at least some embodiments, the table view allows for comparison and contrast of different software components. In at least some embodiments, the table view allows for sorting and filtering of data.

[0046] 6 is a visual representation of a node format according to at least some embodiments of the present disclosure. The visual representation includes representations of software components for a time service 613A, a weather service 613B, a calendar service 613C, a scheduling service 613D, and an administration service 613E. The visual representation further includes connectors 661A, 661B, 661C, and 661D. The visual representation of scheduling service 613D includes a software component name 660, a release tag 663, and a build status 664.

[0047] In at least some embodiments, nodes in the node-format visual representation format represent software components. In at least some embodiments, each software component is represented as a separate node. In at least some embodiments, connectors 661A, 661B, 661C, and 661D indicate dependencies between the software components. In at least some embodiments, the connector arrow is on the side of the dependent software component. In at least some embodiments, these connectors link the nodes. In at least some embodiments, connectors 661A, 661B, 661C, and 661D visually indicate the integration status between different software components.

[0048] In at least some embodiments, the color or style of connectors 661A, 661B, 661C, and 661D is used to indicate the integration status. In at least some embodiments, the integration status is success, failure, or not running. In at least some embodiments, connectors 661A, 661B, 661C, and 661D provide direct feedback regarding the integration status of the software components.

[0049] In at least some embodiments, interaction with a software component changes the visual representation. In at least some embodiments, a node format represents the target software component, the scheduling service 613D, and software components directly related to the target software component. In at least some embodiments, each software component is represented as a node. In at least some embodiments, the node format provides a focused view of a particular software component and its direct dependencies. In at least some embodiments, the representations of the time service 613A, the weather service 613B, the calendar service 613C, and the management service 613E include the software component name, release tag, and build status. In at least some embodiments, a release tag, such as release tag 663, further indicates "OUTDATED" when the release is not the latest, such as in the calendar service 613C. For example, if an integration state is generated between the calendar service 613C and the scheduling service 613D when the calendar service 613C release is not the latest, the release tag for the calendar service 613C explicitly indicates "OUTDATED." In at least some embodiments, the latest release tag information is displayed in response to an interaction with the "OUTDATED" field of the software part in the visual representation.

[0050] In at least some embodiments, the color or style of the connector changes to indicate the integration status. In at least some embodiments, the integration status is successful, failed, or not running. In at least some embodiments, connector 661A indicates a successful integration. In at least some embodiments, connector 661B indicates a failed integration. In at least some embodiments, connectors 661C and 661D indicate not running. In at least some embodiments, the node view shows the direct impact of changes on specific software components.

[0051] 7 is a visual representation in a network format according to at least some embodiments of the present disclosure. The visual representation includes representations of software components for time services 713A, weather services 713B, calendar services 713C, scheduling services 713D, management services 713E, meta services 713F, shell services 713G, packaging services 713H, Wi-Fi services 713J, 5G services 713K, LAN services 713L, communication services 713M, priority services 713N, threading services 713P, routing services 713Q, processing services 713R, and projects 713S.

[0052] In at least some embodiments, the network format includes a node representing each software component. In at least some embodiments, the nodes are interconnected by connectors, such as connectors 761A, 761C, 761D, and 761E. In at least some embodiments, the connectors represent dependencies between the software components in these embodiments. In an embodiment, the connector arrow is on the side of the dependent software component.

[0053] In at least some embodiments, the network format shows all software components and their dependencies. In at least some embodiments, the network format incorporates interactive elements. In at least some embodiments, interaction with a software component changes the visual representation.

[0054] In at least some embodiments, the network format displays all software components and their dependencies. In these embodiments, the dependencies are indicated by connectors. In at least some embodiments, the color or style of the connector indicates a successful, failed, or not running status. In at least some embodiments, the style of connector 761A indicates that the integration between time service 713A and scheduling service 713D was successful. In at least some embodiments, the style of connector 761C indicates that the integration between calendar service 713C and scheduling service 713D was not successful. In at least some embodiments, the style of connector 761D indicates that the integration between scheduling service 713D and management service 713E is not running. In at least some embodiments, the style of connector 761E indicates that the integration between management service 713E and project 713S is not running.

[0055] FIG. 8 is a block diagram of a hardware configuration for visualization of software development, in accordance with at least some embodiments of the present disclosure.

[0056] An exemplary hardware configuration includes a server 800 that interacts with input devices 807 directly or via a network 809 and communicates with a repository 820, a database 822, and client devices 824 via the network 809. In at least some embodiments, the input devices 807 are touchscreens, microphones, cameras, or any other devices configured to detect input, such as tactile, auditory, or visual. In at least some embodiments, the network 809 is an Ethernet network, a controller area network (CAN), or any other wired or wireless network, or a combination thereof. In at least some embodiments, the server 800 is a computer or other computing device that receives input or commands from the input devices 807. In at least some embodiments, the server 800 is integrated with the input devices 807. In at least some embodiments, the server 800 is a computer system that executes computer-readable instructions to perform operations for software development visualization.

[0057] Server 800 includes a controller 802, a storage device 804, an input / output interface 806, and a communication interface 808. In at least some embodiments, controller 802 includes a processor or programmable circuit that executes instructions and causes the processor or programmable circuit to perform operations in accordance with the instructions. In at least some embodiments, controller 802 includes analog or digital programmable circuitry, or any combination thereof. In at least some embodiments, controller 802 includes physically separate storage devices or circuits that interact via communications. In at least some embodiments, storage device 804 includes a non-volatile computer-readable medium capable of storing executable and non-executable data for access by controller 802 during execution of instructions. In at least some embodiments, communication interface 808 transmits and receives data from network 809. In at least some embodiments, input / output interface 806 connects to various input / output units, such as input device 807, via a parallel port, serial port, keyboard port, mouse port, monitor port, etc., to accept commands and current information. In some embodiments, storage device 804 is external to server 800.

[0058] The control unit 802 includes a build section 870 , a read section 872 , a generate section 874 , and a send section 876 , and the storage device 804 includes build parameters 880 , test parameters 882 , a configuration file 884 , and a script 886 .

[0059] The build section 870 is circuitry or instructions of the control unit 802 configured to build a software component. In at least some embodiments, the build section 870 is configured to assign a standby status to an application in response to determining that the application does not have priority. In at least some embodiments, the build section 870 utilizes information in the storage device 804, such as build parameters 880, test parameters 882, and configuration files 884. In at least some embodiments, the build section 870 includes subsections for performing additional functions, as described in the preceding flowcharts. In at least some embodiments, such subsections are referenced by names associated with the corresponding functions.

[0060] The read section 872 is circuitry or instructions in the control unit 802 configured to read a configuration file. In at least some embodiments, the read section 872 is configured to record any display and audio output generated by the application. In at least some embodiments, the read section 872 utilizes information in the storage device 804, such as the configuration file 884. In at least some embodiments, the read section 872 includes subsections for performing additional functions, as described in the preceding flowcharts. In at least some embodiments, such subsections are referenced by names associated with the corresponding functions.

[0061] The generation section 874 is circuitry or instructions in the control unit 802 configured to generate a record. In at least some embodiments, the generation section 874 is configured to modify a record of output generated by an application in response to a request from the application. In at least some embodiments, the generation section 874 utilizes information in the storage device 804, such as a configuration file 884. In at least some embodiments, the generation section 874 includes subsections for performing additional functions, as described in the preceding flowcharts. In at least some embodiments, such subsections are referenced by names associated with the corresponding functions.

[0062] The transmit section 876 is circuitry or instructions in the control unit 802 configured to transmit the recording. In at least some embodiments, the transmit section 876 is configured to play any content of the recording in response to determining that an application has priority. In at least some embodiments, the transmit section 876 utilizes information in the storage device 804, such as script 886. In at least some embodiments, the transmit section 876 includes subsections for performing additional functions, as described in the preceding flowcharts. In at least some embodiments, such subsections are referenced by names associated with the corresponding functions.

[0063] In at least some embodiments, the device is a separate device capable of processing logical functions to perform the operations herein. In at least some embodiments, the controller and memory need not be entirely separate devices, and in some embodiments, share circuitry or one or more computer-readable media. In at least some embodiments, the memory includes a hard drive that stores both computer-executable instructions and data accessed by the controller, and the controller includes a combination of a central processing unit and RAM, where the computer-executable instructions can be copied in whole or in part for execution by the CPU during performance of the operations herein.

[0064] In at least some embodiments where the device is a computer, programs installed on the computer can cause the computer to function as or perform operations associated with the devices of the embodiments described herein, and in at least some embodiments, such programs are executable by a processor to cause the computer to perform specific operations associated with some or all of the blocks in the flowcharts and block diagrams described herein.

[0065] At least some embodiments are described with reference to flowcharts and block diagrams, whose blocks represent (1) steps in a process in which an operation is performed or (2) sections of a controller responsible for performing an operation. In at least some embodiments, particular steps and sections are implemented by dedicated circuitry, programmable circuitry provided with computer-readable instructions stored on a computer-readable medium, and / or a processor provided with computer-readable instructions stored on a computer-readable medium. In at least some embodiments, dedicated circuitry includes digital and / or analog hardware circuitry, including integrated circuits (ICs) and / or discrete circuits. In at least some embodiments, programmable circuitry includes reconfigurable hardware circuitry including logical AND, OR, XOR, NAND, NOR, and other logic operations, flip-flops, registers, memory elements, etc., e.g., field programmable gate arrays (FPGAs), programmable logic arrays (PLAs), etc.

[0066] In at least some embodiments, a computer-readable storage medium comprises a tangible device capable of holding and storing instructions for use by an instruction execution device. In some embodiments, a computer-readable storage medium includes, for example, but is not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of computer-readable storage media includes portable computer diskettes, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM, flash memory), static random access memory (SRAM), portable compact disc read-only memory (CD-ROM), digital versatile disc (DVD), memory sticks, floppy disks, mechanically encoded devices such as punch cards or structures in grooves having instructions recorded thereon, and any suitable combination of the above. As used herein, computer-readable media should not be construed as being transitory signals per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or electrical signals transmitted over a wire.

[0067] In at least some embodiments, the computer-readable program instructions described herein are downloadable to each computing / processing device from a computer-readable storage medium or to an external computer or external storage device over a network, e.g., the Internet, a local area network, a wide area network, and / or a wireless network. In at least some embodiments, the network includes copper transmission cables, optical transmission fibers, wireless transmissions, routers, firewalls, switches, gateway computers, and / or edge servers. In at least some embodiments, a network adapter card or network interface in each computing / processing device receives the computer-readable program instructions from the network and forwards the computer-readable program instructions for storage in a computer-readable storage medium in the respective computing / processing device.

[0068] In at least some embodiments, the computer-readable program instructions for performing the operations described above are assembler instructions, instruction set architecture instructions (ISA), machine instructions, machine-dependent instructions, microcode, firmware instructions, state configuration data, or source or object code written in any combination of one or more programming languages, e.g., object-oriented programming languages ​​such as Smalltalk®, C++®, and traditional procedural programming languages ​​such as the “C” programming language or similar programming languages. In at least some embodiments, the computer-readable program instructions execute entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In at least some embodiments, in the latter scenario, the remote computer is connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection is to an external computer (e.g., via the Internet using an Internet Service Provider). In at least some embodiments, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), executes computer-readable program instructions by utilizing state information of the computer-readable program instructions to individualize the electronic circuitry to perform aspects of the present invention.

[0069] Although the embodiments of the present invention have been described above, the technical scope set forth in the claims is not limited to the above embodiments. Those skilled in the art will understand that various modifications and improvements to the above-described embodiments are possible. Furthermore, those skilled in the art will understand from the claims that forms incorporating such modifications or improvements are also included within the technical scope of the present invention.

[0070] The operations, procedures, steps, and stages of each process performed by the apparatus, system, program, and method shown in the claims, embodiments, or drawings can be performed in any order unless the order is indicated by "previous," "previous," etc., and unless output from a previous process is used in a later process. Note that even if a process flow is described in the claims, embodiments, or drawings using terms such as "first" or "next," the description does not necessarily mean that the processes must be performed in the order described.

[0071] In at least some embodiments, visualizing software development includes, in response to building a plurality of software parts, reading configuration files of the plurality of software parts, the plurality of software parts including a first software part and a second software part, where the second software part depends on the first software part, and generating a record of the plurality of software parts, the record including dependencies between the first software part and the second software part, a build status of the plurality of software parts, and an integration status between the first software part and the second software part.

[0072] In at least some embodiments, the integration status includes one of a success status and a failure status. In at least some embodiments, the integration status includes one of a success status, a failure status, and a not-executed status. In at least some embodiments, the visualization of software development further includes building the plurality of software components. In at least some embodiments, the build status indicates a latest release tag in response to successfully building the plurality of software components. In at least some embodiments, the build status indicates a previous release tag in response to unsuccessfully building the plurality of software components. In at least some embodiments, the visualization of software development further includes receiving instructions to build the plurality of software components. In at least some embodiments, the visualization of software development further includes determining tests indicated in the configuration file. In at least some embodiments, the visualization of software development further includes running tests in response to building the software components to generate test results, the test results indicating the integration status. In at least some embodiments, the visualization of software development further includes building the plurality of software components. In at least some embodiments, the configuration file indicates versions of each input software component used during the build. In at least some embodiments, the record further indicates a time to build the plurality of software components. In at least some embodiments, visualizing the software development further includes providing to the client device a script including instructions for displaying a visual representation of interdependencies between the plurality of software components. In at least some embodiments, the visual representation includes a connector coupling the software component and a second software component. In at least some embodiments, visualizing the software development further includes the connector visually indicating an integration status. In at least some embodiments, the visual representation includes a build status of the second software component.In at least some embodiments, the visualization of software development further includes the visual representation including each software component in a row or column of a table having fields corresponding to a dependency, a build status, and an integration status. In at least some embodiments, the visualization of software development further includes transmitting the record to a database and transmitting the record from the database in response to a request from a client device. In at least some embodiments, the visual representation includes a release tag, the release tag indicating whether the release is an older release. In at least some embodiments, the visualization of software development further includes the script including instructions for switching the visual representation in response to an interaction with the first software component. In at least some embodiments, the visualization of software development further includes the script including instructions for sorting the software components in the table by dependency.

[0073] In at least some embodiments, the visualization of the software development is performed by a processor that executes instructions in accordance with the aforementioned operations, or by an apparatus that includes a controller that includes circuitry configured to perform the aforementioned operations.

[0074] The foregoing summary sets forth features of some embodiments so that those skilled in the art may better understand aspects of the present disclosure. Those skilled in the art should appreciate that this disclosure may readily be used as a basis for designing or modifying other processes and structures for carrying out the same purposes and / or achieving the same advantages of the embodiments presented herein. Those skilled in the art should also appreciate that such equivalent constructions do not depart from the spirit and scope of the present disclosure, and that various changes, substitutions, and alterations can be made herein without departing from the spirit and scope of the present disclosure.

Claims

1. Building a plurality of software components; reading a configuration file of the plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; [0023] In response to execution by one or more processors, instructions cause the performance of operations including: The build status indicates a latest release tag in response to successful build of the plurality of software components; and The computer program product, wherein the build status indicates a previous release tag in response to an unsuccessful build of the plurality of software components.

2. Receiving instructions for building a plurality of software components; reading a configuration file of the plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; determining tests indicated in the configuration file; executing the tests in response to building the software components to generate test results, the test results indicating the integration status; 1. A computer program having instructions that, in response to execution by one or more processors, cause the performance of operations including:

3. reading a configuration file of a plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; providing a script to a client device, the script including instructions for displaying a visual representation of interdependencies between the plurality of software components; 1. A computer program having instructions that, in response to execution by one or more processors, cause the performance of operations including:

4. The computer program product of claim 1 , wherein the integrated status comprises one of a success status and a failure status.

5. The computer program product according to any one of claims 1 to 3, wherein the integrated status comprises one of a success status, a failure status, and a non-execution status.

6. A computer program as described in any one of claims 1 to 3, wherein the configuration file indicates the version of each input software component used during the construction.

7. The computer program product according to any one of claims 1 to 3, wherein the record further indicates a time when the plurality of software components are constructed.

8. The computer program product of claim 3 , wherein the visual representation includes a connector that couples the software component with a second of the software components.

9. The computer program product of claim 8 , wherein the connector visually indicates the integration status.

10. The computer program product of claim 8 , wherein the visual representation includes the build status of a second of the software components.

11. The computer program product of claim 8 , wherein the visual representation includes each of the software components in a row or column of a table having fields corresponding to the dependency relationships, the build status, and the integration status.

12. 9. The computer program product of claim 8, wherein the actions further include transmitting the record to a database and transmitting the record from the database in response to a request from the client device.

13. The computer program product of claim 8 , wherein the visual representation includes a release tag, the release tag indicating whether the release is an older release.

14. The computer program product of claim 3 , wherein the script includes instructions for switching the visual representation in response to an interaction with the first software component.

15. The computer program product of claim 11 , wherein the script includes instructions for sorting the software components in the table by the dependencies.

16. Building a plurality of software components; reading a configuration file of the plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; The processor executes The build status indicates a latest release tag in response to successful build of the plurality of software components; and The method, wherein the build status indicates a previous release tag in response to an unsuccessful build of the plurality of software components.

17. Receiving instructions for building a plurality of software components; reading a configuration file of the plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; determining tests indicated in the configuration file; executing the tests in response to building the software components to generate test results, the test results indicating the integration status; How the processor performs the

18. reading a configuration file of a plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; providing a script to a client device, the script including instructions for displaying a visual representation of interdependencies between the plurality of software components; How the processor performs the 19. Constructing a plurality of software components; reading a configuration file of the plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; a controller including circuitry configured to perform operations including The build status indicates a latest release tag in response to successful build of the plurality of software components; and The build status indicates a previous release tag in response to an unsuccessful build of the plurality of software components.

20. Receiving instructions for building a plurality of software components; reading a configuration file of the plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; determining tests indicated in the configuration file; executing the tests in response to building the software components to generate test results, the test results indicating the integration status; 10. An apparatus having a controller including circuitry configured to perform operations including:

21. reading a configuration file of a plurality of software components in response to building the plurality of software components, the plurality of software components including a first software component and a second software component, the second software component being dependent on the first software component; generating a record of the plurality of software components, the record including a dependency relationship between the first software component and the second software component, a build status of the plurality of software components, and an integration status between the first software component and the second software component; providing a script to a client device, the script including instructions for displaying a visual representation of interdependencies between the plurality of software components; 10. An apparatus having a controller including circuitry configured to perform operations including:

Images