Software library reconstruction method and software library reconstruction device

Abstract

To reconstruct a software library for a device having restricted hardware resources.SOLUTION: A software library reconstruction method executed by utilizing a general-purpose software library executes the processes of: extracting only a used part of a library of Python and reconstructing a library of Python on an original development environment for developing Python; checking errors of MicroPython on the basis of a reconstructed library on a virtual execution framework in which MicroPython that is compatible with Python and is lighter than Python is executed; and reconstructing a software program of MicroPython constituted of a library only for a used part on the basis of error-checked MicroPython.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The present invention relates to a software library reconstruction method and a software library reconstruction device. [Background technology]

[0002] Recently, as software applications have become more multifunctional and complex, general-purpose software libraries such as OSS (Open Source Software) that allow specific functional extensions, and Python (registered trademark)-based programs that utilize these libraries, have become increasingly popular.

[0003] Python was originally designed to run on PC (Personal Computer)-based devices (such as servers running an OS (Operating System) such as Linux (registered trademark) or Windows (registered trademark)) that do not have strict constraints on hardware resources such as RAM and storage capacity. Therefore, even if the general-purpose software libraries and associated software packages required to run the program become huge in size, it was usually not a major problem because the storage capacity could be expanded as needed.

[0004] However, in recent years, due to the ease of use of Python, embedded platform technologies such as MicroPython, which allows Python programs to be executed on devices with limited hardware resources such as microcontrollers (hereafter referred to as "microcomputers"), have begun to spread. Generally, Python software libraries have many functions in one library to enhance versatility. For this reason, even if an actual program only uses a portion of a library, it is essential that the entire library, and even its accompanying packages, be installed within the hardware resources of the device on which the program runs.

[0005] This is unrealistic to achieve in an embedded environment implemented on a microcontroller or the like due to hardware resource constraints, and in order for a Python program to run on a device such as a microcontroller, it is necessary to minimize the resources occupied by the library as much as possible.

[0006] For example, Patent Document 1 discloses a method of extracting only necessary functional elements from a software library and reconstructing the library on a device in a real environment such as a car navigation system. [Prior art documents] [Patent documents]

[0007] [Patent Document 1] International Publication No. 2011 / 055417 Summary of the Invention [Problem to be solved by the invention]

[0008] However, in the technology described in Patent Document 1, the purpose of library optimization is to reduce RAM consumption and program execution time by optimizing software libraries that have already been implemented in a program execution environment and whose operation has been confirmed. Therefore, in the technology described in Patent Document 1, it is necessary to reconstruct the library on a device in the actual environment, which means that the entire huge library, as well as all of the accompanying packages, must be loaded onto the device at once.

[0009] While devices with large hardware resources, such as those used in car navigation systems, have relatively large on-board storage capacity and are therefore capable of installing entire libraries and associated packages, it has been difficult to install entire software libraries and associated packages on devices with limited hardware resources, such as microcontrollers. In other words, on devices with limited hardware resources, software libraries cannot be implemented in the program execution environment unless they are optimized, and it is naturally impossible to check the operation of the rebuilt program. As a result, it has become difficult to rebuild software libraries on devices with limited hardware resources.

[0010] The present invention has been made in view of the above circumstances, and has as its object to provide a software library reconstruction method that can reconstruct a software library for a device with limited hardware resources. [Means for solving the problem]

[0011] A software library reconstruction method according to an embodiment of the present invention is a software library reconstruction method executed using a general-purpose software library, and is characterized by executing the following processes: in an original development environment in which a first program is developed, a process of extracting only the used parts of the library of the first program and reconstructing the library of the first program; in a virtual execution platform in which a second program that is compatible with the first program and lighter than the first program is executed, a process of performing an error check on the second program based on the reconstructed library; and a process of reconstructing a software program of the second program composed of a library of only the used parts based on the second program for which the error check has been performed. [Effects of the Invention]

[0012] According to the present invention, it is possible to reconstruct a software library for a device with limited hardware resources. [Brief explanation of the drawings]

[0013] [Figure 1] 1 is a diagram illustrating an example of a functional configuration of a software library reconstruction device according to an embodiment of the present invention. [Figure 2] FIG. 10 is a diagram illustrating an example of a function correspondence list according to the embodiment of the present invention. [Figure 3] 10 is a flowchart illustrating an example of a software library reconstruction process executed by the software library reconstruction device according to the embodiment of the present invention. DETAILED DESCRIPTION OF THE INVENTION

[0014] Hereinafter, an embodiment of a software library reconstruction device that executes a software library reconstruction method according to the present invention will be described with reference to the drawings. Fig. 1 is a diagram showing an example of the functional configuration of a software library reconstruction device 10 according to an embodiment of the present invention.

[0015] As shown in FIG. 1, a software library reconstruction device 10 is a general-purpose device such as a development host PC (Personal Computer) on which a developer develops a program.

[0016] The software library reconstruction device 10 extracts only the functional elements necessary for executing a second program compatible with a first program from the general-purpose software library of the first program and its associated software package, deletes unused elements, and then reconstructs the software library of the second program compatible with the first program. The device then has a function to verify in a software development environment whether the actual program can run on the embedded platform on which the second program is installed, using the reconstructed second software library. This allows the software library to be reconstructed on devices with limited hardware resources, such as microcontrollers.

[0017] The second program is configured with a software library that is lighter than the first program. In an embodiment of the present invention, Python (registered trademark) can be used as the first program, and MicroPython can be used as the second program. Note that in the embodiment of the present invention, the first program is described based on Python, but is not limited to Python and may be an interpreted language. An example of an interpreted language may be a scripting language such as JavaScript (registered trademark).

[0018] To explain the need to rebuild software libraries on devices with limited hardware resources, MicroPython is a Python-based language but is not fully compatible with Python. Because MicroPython was designed for use on microcontrollers with limited hardware resources, many features have been shrunk from Python to make it lightweight. This means that even if a program executed using a rebuilt library runs on Python, it may not necessarily run on MicroPython. If the operation of the optimized libraries in a MicroPython program is verified in an embedded environment with limited hardware resources, such as a microcontroller (the final target device), the development time required to implement and test the program in the embedded environment is lengthened. This significantly reduces development efficiency compared to verification on a development host PC. Therefore, there is a need for a system that allows development on a development host PC rather than on the actual final target device, such as a microcontroller. Therefore, in an embodiment of the present invention, a software library reconstruction device 10 is configured as shown in Figure 1.

[0019] 1, the software library reconstruction device 10 includes a software library reconstruction unit 100, a Python program storage unit 150, a MicroPython program storage unit 160, and a function correspondence list 170. The software library reconstruction device 10 may include other components not shown in FIG.

[0020] The Python program storage unit 150 is realized by a storage device of the software library reconstruction device 10. The storage device may be realized by, for example, a ROM (Read Only Memory), a RAM (Random Access Memory), a flash memory, etc. The Python program storage unit 150 stores a Python execution program 151 and a software library 152 required for executing the Python execution program 151.

[0021] An example of the software library 152 will be described using the machine learning library scikit-learn. In this case, the software library 152 stores the scikit-learn main software and accompanying packages of scikit-learn, such as numpy software, scipy software, and joblib software. Also, accompanying software packages are stored for the numpy software, scipy software, and joblib software.

[0022] In other words, even if a Python program actually uses only the numpy software functions, the entire program cannot be executed unless unused scipy software, joblib software, and all associated software packages are installed on the device or other embedded equipment. Therefore, even if you want to use some of the scikit-learn functions, you need to allocate storage resources of around 60MB on the embedded device or other device for the program itself and associated packages. However, since the storage capacity of a microcontroller is around 10KB to several MB, it is difficult to use programs such as Python on devices with limited hardware resources, such as microcontrollers.

[0023] Therefore, the software library reconstruction unit 100 extracts only the functional elements necessary for executing the program from the general-purpose software library to be used and the accompanying software package, and then reconstructs the software library after deleting the unused elements.

[0024] The software library reconstruction unit 100 includes a program extraction unit 110, a Python program verification unit 120, a MicroPython program verification unit 130, and a program optimization unit 140. The software library reconstruction unit 100 may include other components not shown in FIG. 1. The software library reconstruction unit 100 is configured in a control device of the software library reconstruction device 10. The control device is realized by, for example, a CPU (Central Processing Unit) or an MPU (Micro Processor Unit).

[0025] The program extraction unit 110 reads the Python execution program 151 and software library 152 stored in the Python program storage unit 150. Then, from the read Python execution program 151 and software library 152, it extracts only the functional elements necessary for executing the MicroPython program on the microcomputer 20. The functional elements necessary for executing the MicroPython program mean, for example, a software library with a minimum configuration.

[0026] The program extraction unit 110 comments out the code of the part of the library that is not used other than the software library of the minimum configuration. For example, the program extraction unit 110 performs processing to comment out the difference, obtained by subtracting the part of the library that corresponds to the extracted functional element, by adding a comment notation before or after the code of the part of the library that is not used.

[0027] For example, a case will be described where the machine learning library scikit-learn is used as the software library 152. The scikit-learn package is accompanied by numpy software, scipy software, joblib software, and software packages for each software.

[0028] That is, even if a program desired to be used with MicroPython only includes the numpy software functions, it will contain unused scipy software, joblib software, and associated software packages. Therefore, the program extraction unit 110 executes a process to extract only the numpy software and associated library functions required for execution on the microcomputer 20 from the Python execution program 151 and the software library 152. This reduces the amount of data in the software library to be installed on a device such as a microcomputer, and enables the software library to be rebuilt for a device with limited hardware resources.

[0029] As the functional elements required for execution, for example, when the software library reconstruction unit 100 executes the Python execution program 151 and the software library 152, the program elements actually used may be associated.

[0030] The Python program verification unit 120 verifies whether the Python program from which the unused elements have been deleted is operable as a result of extraction by the program extraction unit 110. For example, the Python program verification unit 120 performs an error check on the program in the original execution environment, i.e., the development environment of the Python program.

[0031] If the verification results in the program being operable, i.e., if the program operates OK even after commenting out, the Python program verification unit 120 reconstructs a library of only the extracted functional elements as an optimized library. The Python program verification unit 120 verifies whether the program is operable by verifying the program elements extracted by the program extraction unit 110 and the relationships between the program elements. For example, the Python program verification unit 120 verifies whether there are any errors in the source code of the extracted program elements and identifies identical program logic by comparing the program elements.

[0032] If the verification results in the program being inoperable, i.e., if the program fails to run as a result of commenting out the parts, the Python program verification unit 120 displays an error message and resets the commented-out parts. For example, the Python program verification unit 120 controls the display of an error message on a display or the like for a program determined to be in error. The Python program verification unit 120 also removes the comment notation from the commented-out parts, restores them as code, and resets the commented-out parts. The commented-out parts may be reset by the Python program verification unit 120 based on the error message, or the developer who checks the error message may restore the code corresponding to the error message. After resetting the commented-out parts, the Python program verification unit 120 performs program verification.

[0033] If the verification by the Python program verification unit 120 shows that the program works OK, the MicroPython program verification unit 130 performs an error check on the program in a virtual execution environment, i.e., on a virtual execution platform on which MicroPython is pseudo-imitated (hereinafter also referred to as "emulated").

[0034] The MicroPython program verification unit 130 includes a program verification unit 131 and a virtual execution platform 132. The program verification unit 131 verifies whether the actual program verified by the Python program verification unit 120 can run on the virtual execution platform 132. For example, the program verification unit 131 performs an error check on the program on the virtual execution platform 132.

[0035] The virtual execution platform 132 is an environment in which MicroPython is executed. For example, when the program execution environment is MicroPython, the virtual execution platform 132 refers to an environment in which MicroPython is pseudo-simulated on Python in the development environment, i.e., an execution platform in which MicroPython is emulated. Emulation by the virtual execution platform 132 makes it possible to build a mechanism that can absorb differences in available functions and functions themselves between Python and MicroPython.

[0036] Because MicroPython is not completely identical to Python, even if a program verified by the Python program verification unit 120 runs on Python, it does not necessarily run on MicroPython. For this reason, in an embodiment of the present invention, verification of whether the program can run on a MicroPython program on a general-purpose development host PC is performed. This allows program verification during software library reconstruction to be performed on the virtual execution platform 132, which is a virtual program execution platform, on a general-purpose PC that is easy to develop on, rather than on an actual device such as the microcontroller 20. As a result, it becomes possible to verify the operation of the software library in an embedded device environment in the development environment, thereby shortening the development period.

[0037] The MicroPython program verification unit 130 converts functions used in Python into functions used in MicroPython, for example, by referring to a function correspondence list 170 shown in Fig. 2. Fig. 2 is a diagram showing an example of the function correspondence list 170 according to an embodiment of the present invention. The function correspondence list 170 is realized by a storage device of the software library reconstruction device 10. The storage device may be realized by, for example, a ROM, a RAM, a flash memory, or the like.

[0038] The left column of the function correspondence list 170 stores Python functions used in Python, and the right column stores MicroPython functions used in MicroPython. The MicroPython program verification unit 130 references the function correspondence list 170 and replaces the Python functions listed in the left column with the MicroPython functions listed in the right column in the Python program verified by the Python program verification unit 120. Note that each MicroPython library is not fully compatible with the Python library and many have limited functionality. For this reason, functions that cannot be used in MicroPython can be realized by creating a program with equivalent functionality using a different library. Note that, among the Python functions listed in the function correspondence list 170, the timer function of "timeit.default_timer" can be substituted with a program using the "utime" function.

[0039] The program verification unit 131 verifies whether the MicroPython program from which unused elements have been deleted is operable. For example, the program verification unit 131 performs an error check on the program on the virtual execution platform 132, i.e., on the environment of the MicroPython program.

[0040] If the verification results in the program being operable, i.e., if the program operates OK after conversion to a MicroPython program, the program verification unit 131 reconstructs a library of only the extracted functional elements as an optimized library. The program verification unit 131 verifies whether the program is operable by verifying the reconstructed program elements and the relationships between the program elements. For example, it verifies whether there are any errors in the source code of the extracted program elements and identifies identical program logic by comparing program elements.

[0041] If the verification results in the program being inoperable, i.e., if the program's operation is unsuccessful as a result of commenting out, the program verification unit 131 displays an error message and compares the original execution environment with the virtual execution environment and performs additional code corrections.

[0042] For example, the program verification unit 131 controls the display of an error message on a display or the like for a program determined to have an error. The program verification unit 131 also compares the original execution environment with the virtual execution environment by comparing functions used in the Python environment with functions used in the MicroPython virtual environment. The program verification unit 131 also performs additional code corrections by removing the comment notation from commented-out portions and restoring them as code, or by adding other code. The additional code corrections may be performed by the program verification unit 131 based on an error message, or by a developer who has confirmed the error message and added code corresponding to the error message. After the additional code corrections have been performed, the program verification unit 131 performs program verification again.

[0043] The program optimization unit 140 extracts only the functional elements necessary for program execution from the MicroPython program verified by the MicroPython program verification unit 130, deletes unused elements, and then rebuilds the software library. For example, after program verification in the MicroPython virtual environment is completed, the program optimization unit 140 converts the verified Python program into a MicroPython program to generate the MicroPython program. Then, the program optimization unit 140 performs a process of deleting commented-out code from the generated MicroPython program, thereby extracting only the functional elements necessary for program execution, deletes unused elements, and then rebuilds the software library.

[0044] The program optimization unit 140 stores the reconstructed MicroPython program in the MicroPython program storage unit 160. The MicroPython program storage unit 160 is realized by a storage device of the software library reconstruction device 10. The storage device may be realized by, for example, a ROM, RAM, flash memory, etc. The MicroPython program storage unit 150 stores a MicroPython execution program 161 and a software library 162 with a minimum configuration required to execute the MicroPython execution program 161.

[0045] The minimum software library 162 stores a library reconstructed by the program optimization unit 140. That is, only the minimum libraries required for the MicroPython execution program 161 executed on the microcomputer 20 to be executed are extracted from the Python program, or converted as necessary and stored as the minimum software library 162.

[0046] The reconfigured MicroPython execution program 161 stored in the MicroPython program storage unit 160 and the required minimum software library 162 are loaded onto the microcomputer 20.

[0047] The microcomputer 20 is configured from a device such as an embedded device with limited hardware resources. The microcomputer 20 executes programs reconstructed by the software library reconstruction device 10. The microcomputer 20 includes a program storage memory 210, a program processing memory 220, and a program calculation unit 230. The microcomputer 20 may include other components not shown in FIG. 1.

[0048] The program storage memory 210 stores the program reconstructed by the software library reconstruction device 10. The program storage memory 210 is realized by a storage device of the microcomputer 20. The storage device may be realized by, for example, a ROM, a RAM, a flash memory, etc. The program storage memory 210 stores the MicroPython execution program 161 stored in the MicroPython program storage unit 160 and a software library 162 with the minimum required configuration.

[0049] The program processing memory 220 is used as a working area that is expanded and used when the program calculation unit 230 executes the MicroPython execution program 161 and the minimum software library 162 stored in the program storage memory 210. The program processing memory 220 is realized by a storage device of the microcomputer 20. The storage device may be realized by, for example, a ROM, a RAM, a flash memory, or the like.

[0050] The program calculation unit 230 is realized by a control device of the microcomputer 20. The control device may be realized by, for example, a CPU or an MPU. The program calculation unit 230 loads the MicroPython execution program 161 and the minimum software library 162 stored in the program storage memory 210 into the program processing memory 220 and executes the program. The program calculation unit 230 outputs data obtained by executing the program to an external device such as a server (not shown) via an external communication interface (not shown). The external communication interface is realized by a communication device that is part of another component of the microcomputer 20 (not shown in FIG. 1). The communication device may be realized by, for example, Wi-Fi, Bluetooth (registered trademark), Ethernet (registered trademark), etc.

[0051] The software library reconstruction process executed by the software library reconstruction device 10 according to the embodiment of the present invention will be described with reference to Fig. 3. Fig. 3 is a flowchart showing an example of the software library reconstruction process executed by the software library reconstruction device 10 according to the embodiment of the present invention.

[0052] First, the software library reconstruction unit 100 reads the Python execution program 151 and the software library 152 from the Python program storage unit 150 (step S101).

[0053] The software library reconstruction unit 100 performs software structure analysis based on the Python execution program and software library read in step S101 and extracts the library usage portion (step S102). From the Python execution program 151 and software library 152 read in the processing of step S101, only the functional elements necessary for executing the MicroPython program on the microcomputer 20 are extracted. The functional elements necessary for executing the MicroPython program mean, for example, the minimum necessary software and libraries.

[0054] The software library reconstruction unit 100 comments out the code of the part of the library that is not used (step S103). In this process, the difference obtained by subtracting the part of the library that is used extracted in step S102 from the execution program and software library that were read in step S101 is commented out by adding comment notation before or after the code of the part of the library that is not used.

[0055] The software library reconstruction unit 100 performs an error check on the program in the original execution environment (step S104). In this process, after commenting out unused parts of the library in the process of step S103, it is verified whether the Python program is operable or not.

[0056] The software library reconstruction unit 100 determines whether the operation is OK as a result of the error check performed in step S104 (step S105). In this process, a check is performed to verify whether the Python program is not executable as a result of commenting out in step S103.

[0057] If the result of the error check in the Python environment in step S104 is that the program does not run (step S105: NO), the software library reconstruction unit 100 displays an error message and resets the commented-out portion (step S106). In this process, an error message is displayed for the program that was determined to have an error as a result of the error check in step S104. The resetting of the commented-out portion involves removing the comment notation from the portion that was commented out in the process of step S103 and restoring it to code again. The resetting of the commented-out portion may be performed by the software library reconstruction unit 100 restoring the code based on the error message, or by the developer who has confirmed the error message restoring the code corresponding to the error message.

[0058] If the result of the error check on the Python environment in step S104 is that the program operates OK (step S105: YES), the software library reconstruction unit 100 performs an error check on the program on the virtual execution platform 132 (step S107). In this process, once program verification in the Python environment is complete, the process proceeds to verification of the MicroPython virtual environment, where an error check is performed.

[0059] The software library reconstruction unit 100 determines whether the operation is OK as a result of the error check performed in step S107 (step S108). In this process, the function correspondence list 170 in Fig. 2 is imported and a check is performed to verify whether the program remains a Python program but is unable to run on MicroPython.

[0060] If the result of the error check on the MicroPython virtual environment in step S108 is that the operation is not possible (step S108: NO), the software library reconstruction unit 100 displays an error message and compares the original execution environment with the virtual execution environment and performs additional code corrections (step S109).

[0061] In this process, an error message is displayed for any program determined to have an error as a result of the error check in step S107. Furthermore, the comparison between the original execution environment and the virtual execution environment involves a process of contrasting the functions used in the Python environment with the functions used in the MicroPython virtual environment. Furthermore, additional code correction involves removing the comment notation from the portion commented out in step S103 and restoring it as code, or adding other code. The additional code correction may be performed by the software library reconstruction unit 100 based on the error message, or by a developer who has checked the error message and added the code corresponding to the error message.

[0062] If the result of the error check in the MicroPython virtual environment in step S108 is that the operation is OK (step S108: YES), the software library reconstruction unit 100 generates a MicroPython program and deletes the code in the commented-out portions (step S110). In this process, once program verification in the MicroPython virtual environment is complete, the verified Python program is converted into a MicroPython program to generate the MicroPython program. Then, a process is performed to delete the code in the commented-out portions from the generated MicroPython program.

[0063] The software library reconstruction unit 100 reconstructs the MicroPython program and the minimized library as new software (step S111). Then, the software library reconstruction unit 100 stores (registers) the MicroPython execution program 161 and the minimum software library 162 reconstructed in step S111 in the MicroPython program storage unit 160 (step S112).

[0064] The MicroPython execution program 161 stored in the MicroPython program storage unit 160 and the required minimum software library 162 are loaded onto the microcomputer 20.

[0065] The software library reconstruction method executed by the software library reconstruction device 10 according to this embodiment extracts only the used portions of a Python library in the original development environment where Python is developed, and reconstructs the Python library. Then, on a virtual execution platform where MicroPython, which is compatible with Python and lighter than Python, runs, an error check for MicroPython is performed based on the reconstructed library. A MicroPython software program composed of libraries containing only the used portions is reconstructed based on the error-checked MicroPython.

[0066] This allows software to be rebuilt using the software library reconstruction device 10, such as a general-purpose PC, which is easy to develop, rather than on an actual device such as a microcomputer 20. As a result, program verification during software library reconstruction can be performed on the virtual execution platform 132, which is a virtual program execution platform. As a result, software libraries can be rebuilt for devices with limited hardware resources. This also makes it possible to verify the operation of software libraries in an embedded device environment in the development environment, thereby shortening the development period. [Industrial Applicability]

[0067] The software library reconstruction method of the present invention has the effect of being able to reconstruct a software library for a device with limited hardware resources, and is suitable for any software library reconstruction device. [Explanation of symbols]

[0068] 10: Software library reconstruction device 100: Software Library Reconstruction Department 110: Program extraction section 120: Python Program Verification Section 130: MicroPython Program Verification Section 131: Program Verification Department 132: Virtual Execution Platform 140: Program Optimization Department 150: Python program memory 151: Python executable 152: Software Library 160: MicroPython program storage 161: Executable program for MicroPython 162:Minimum software library 170: Function correspondence list 20: Microcomputer 210: Program storage memory 220: Program processing memory 230: Program calculation unit

Claims

1. A software library reconstruction method executed by a computer using a general-purpose software library, comprising: A process of extracting only the used portion of a library of the first program and reconstructing the library of the first program in an original development environment in which the first program is developed; a process of performing an error check on a virtual execution platform on which a second program that is compatible with the first program and lighter in weight than the first program is executed, based on the reconstructed library; a process of reconstructing a software program of the second program configured with a library of only the used portions based on the second program that has undergone the error check; The software library reconstruction method is characterized in that the computer executes the above steps.

2. 2. The software library reconstruction method according to claim 1, The process of performing the error check on the second program is executed on a virtual execution platform in which an execution environment of the second program is emulated on a development environment of the first program. A software library reconstruction method comprising:

3. 3. The software library reconstruction method according to claim 1, further comprising: The process of rebuilding the library of the first program includes: extracting the used portion of the software library by commenting out unused code in the software library; and a process in which the computer reconstructs the library of the first program from which the used portion has been extracted by commenting out. A software library reconstruction method comprising:

4. 4. The software library reconstruction method according to claim 3, The process of reconstructing the software program of the second program includes: a process in which the computer deletes the code in the commented-out portion; and a process in which the computer reconstructs the software program of the second program, which is configured with the library of only the used portion, based on the library of the second program from which the code has been deleted. A software library reconstruction method comprising:

5. 5. A software library reconstruction method according to claim 1, further comprising: The first program and the second program are in an interpreted language. A software library reconstruction method comprising:

6. 6. A software library reconstruction method according to claim 1, comprising: the language of the first program is Python (registered trademark); The language of the second program is MicroPython. A software library reconstruction method comprising:

7. A software library reconstruction device including a software library reconstruction unit that is executed by using a general-purpose software library, The software library reconstruction unit In an original development environment in which a first program is developed, extracting only the used portion of the library of the first program and reconstructing the library of the first program; performing an error check on the second program based on the reconstructed library on a virtual execution platform on which a second program that is compatible with the first program and lighter in weight than the first program is executed; Reconstructing a software program of the second program, which is configured from a library of only the used portions, based on the second program for which the error check has been performed. A software library reconstruction device characterized by:

Images