## 2 Materials and Methods
It establishes virtual connections, emulating physical cables and enabling smooth transmission of commands, data, and status information. This approach ensures secure and high-speed communication within the software ecosystem. Figure 6: Internal notes that the master modules write and share with each other based on their training and error and status information obtained from their communication with the slave modules. The prototype files used for the virtual wiring operation inspired by the I2C protocol are SCL and SDA files. This communication prototype allows us to lower the reading speeds of the files, since using other file types such as txt, json, etc., would have a linear algorithmic complexity of O(N), depending on the amount of data to be read. On the other hand, using virtual wires based on the I2C protocol allows us to have an algorithmic complexity of O(1) since the file structures allow us to read them line by line in 1024-bit packets, as they do not store all lines of the file in memory simultaneously. Instead, it reads one line at a time and processes each line before reading the next one. In terms of time, a file's complexity depends on its size and the number of lines it contains. In the worst case, if the file has N lines, it will be executed N times, resulting in a time complexity of O(N) because each line of the file must be read and processed. However, we must consider that the time complexity can also be affected by the processing performed on each line. If the processing of each line has a complexity greater than O(1), then the overall complexity of the code will be determined by the processing rather than by the file reading. In summary, the space complexity is O(1), and the time complexity is O(N), where N is the number of lines in the file. However, if we base communication on JSON files, the time and space complexity of this code is O(N), where N is the number of lines in the file. In terms of software development practices, the team followed an agile methodology, incorporating continuous integration and deployment processes. Version control systems like Git were used to track changes and facilitate collaboration among developers. The software was thoroughly tested using unit tests, integration tests, and system tests to ensure its robustness and reliability. To enhance the software, the following additional tools, software, and frameworks were employed during development:  
Docker: The software was containerized using Docker, providing a portable and reproducible environment for seamless deployment on different platforms. Flask: The Flask web framework was used to develop a user-friendly web interface for managing and monitoring the software's activities, allowing users to interact with the system and view real-time updates. OpenCV: The OpenCV library was used for advanced image processing tasks, enabling the software to perform complex visual analysis and recognition. Selenium: Selenium WebDriver was used to automate web browser interactions, allowing the software to navigate websites and perform tasks that require user-like interactions. Figure 7: Information extracted in response to a change in the location of a critical button for the progress of the activity intended for the slave modules. Scikit-learn: Scikit-learn, a popular machine learning library, was used to train and deploy machine learning models within the software, enhancing its ability to make data-driven decisions. Pandas: The Pandas library was employed for efficient data manipulation and analysis, enabling the software to process large datasets and generate insightful reports. Jupyter Notebook: Jupyter Notebook was used for prototyping, experimentation, and data exploration during the software development cycle, facilitating an agile and iterative development process. The self-adaptive software developed for pre-programmed tasks on the Internet, as described in this study, runs on hardware optimized for efficient and reliable performance.