Graphical User Interface Reliability Prediction Based on Architecture and Event Handler Interaction

In software development process, the last step is usually the Graphic User Interface(GUI) test, which is part of the final user experience (UE) test. Traditionally, there exist some GUI test tools in the market, such as Abbot Java GUI Test Framework and Pounder, in which testers pre-configure in the script all desired actions and instructions for the computer, nonetheless requiring too much of invariance of GUI environment; and they require reconfiguration in case of GUI changes, therefore still to be done mostly manually and hard for non-programmer testers to. Consequently, we proposed GUI tests by image recognition to automate the last process; we managed to innovate upon current algorithms such as SIFT and Random Fern, from which we develop the new algorithm scheme retrieving most efficient feature and dispelling inefficient part of each algorithm. Computers then apply the algorithm, to search for target patterns themselves and take subsequent actions such as manual mouse, keyboard and screen I/O automatically to test the GUI without any manual instructions. Test results showed that the proposed approach can accelerate GUI test largely compared to current benchmarks.

Requirement of software is necessary for the process system-computer simulation. ln reality, costly of software is one of restriction for the software development. However, the costly constraint can be solved using open source software such as Scilab and OpenOffice. The goa lof this article formulates user friendly program of the process system. Scilab program by Graphical User Interface (GUI) and interaction with Open Office-Cale for the data-base physical property. Scilab program has been listed in this article and algorithme of rhe program as the methodology has been presented in this article. Results of the simulation program indicate goodfinding for the process system. Kata kunci : scilab; open office, simulasi komputer; oss (open source sortuare), Antar Muka Pcngguna - Graphical User Interface (GUI).

The scale of software on digital AV appliances that handle large‐volume multichannel digital data has been increased by the GUIs (graphical user interfaces) loaded on them in recent years. In addition, the GUIs of AV appliances use remote controls having cursor keys. Focus management must be performed by these to point to the object of operation, in contrast to the mouse, which is capable of pointing on the entire screen. Since focus management changes with changes in the specifications of GUIs, such as screen layouts and the like, software may not be reusable. In this paper, a development system that attempts to improve the productivity of GUI software requiring focus management is discussed from the points of view of (1) a software design model based on an object‐oriented MVC model, (2) an execution model with good efficiency corresponding to the design model, (3) development tools performing synthesis of GUI software and automatic generation of focus management procedures, and (4) applications and evaluations of the system. In an example of the application of the system, software productivity with a GUI specification change was improved by a factor of three. © 2003 Wiley Periodicals, Inc. Syst Comp Jpn, 34(7): 99–107, 2003; Published online in Wiley InterScience (www.interscience.wiley.com). DOI 10.1002/scj.10018

Software testing in general and graphical user interface (GUI) testing in particular is one of the major challenges in the lifecycle of any software system. GUI testing is inherently more difficult than the traditional and command-line interface testing. Some of the factors that make GUI testing different from the traditional software testing and significantly more difficult are: a large number of objects, different look and feel of objects, many parameters associated with each object, progressive disclosure, complex inputs from multiple sources, and graphical outputs. The existing testing techniques for the creation and management of test suites need to be adapted/enhanced for GUIs, and new testing techniques are desired to make the creation and management of test suites more efficient and effective. In this article, a methodology is proposed to create test suites for a GUI. The proposed methodology organizes the testing activity into various levels. The tests created at a particular level can be reused at higher levels. This methodology extends the notion of modularity and reusability to the testing phase. The organization and management of the created test suites resembles closely to the structure of the GUI under test.

Graphical User Interfaces (GUIs) represent a key part for building interactive applications, and they act as a direct interface between users and software. The complexity of the GUIs increases in relation to the number of users interacting with software and performing multiple complex tasks, resulting in software that are mazes of functionalities. The impact of such a GUI system is adverse on the software quality and may result in non-robust software. To measure software quality, one has to measure attributes such as usability, efficiency, and learnability. There is no general approach for measuring software validity subjectively in a non-invasive way, i.e., without directly asking the users to evaluate directly the software through predefined use cases or through questionnaires. In this paper, we investigate this issue by detecting the presence of potential errors in GUIs by using the users gaze information collected during user interactions. Users gaze is analyzed to generate thirteen unique features based on statistical moments based on the time spent on each control, gaze path, and transitions between controls on the different GUI components present on the screen. The performance is evaluated with five state of the art classifiers. The results support the conclusion that incongruent GUI states can be reliably detected at the single trial level through gaze-based features with an accuracy of 76% (one-versus-rest classification) and 73.66 (one-versus-one classification) using a Gaussian Naive Bayes classifier. These results suggest the possibility of co-development approaches between early stage users and developers through eyetracking.

Globalization technology has made localization a critical aspect of software development. Localizing graphical user interfaces (GUIs) for Right-to-Left (RTL) languages, such as Arabic and Hebrew, requires unique considerations and design approaches compared to Left-to-Right (LTR) languages. As the global market for RTL-speaking users continues to grow, organizations must focus on developing culturally and linguistically appropriate GUIs. In this study, we focused on the localization of the GUI for RTL languages. We aimed to identify the challenges associated with localizing UIs for RTL languages for organizations interested in this area. One of the main challenges we encountered during the project was the need for more standardization for RTL UI design in general. Although both Apple and Google offer style guides for Arabic language localization, we found that these guides needed to address the complexities of RTL design fully. The user experience design presented several issues that required us to make alternative decisions in the RTL design.Contrary to popular belief, changing the design from LTR to RTL is more complex than mirroring elements in the design. The physical reach of the user can be affected, and cultural values and design preferences should be an integral part of the design decision-making process. For example, hierarchy is conveyed differently in RTL languages than in LTR languages, requiring a unique approach to UI design. Our study also found that RTL languages (Arabic) have unique typographical considerations, such as text direction and word wrapping, which can significantly impact the user experience. To address these considerations, we had to make several modifications to the UI, including adjusting the placement of elements, adjusting the size and spacing of text, and incorporating appropriate text direction. Organizations must consider cultural values and design preferences in their design decision-making process when localizing GUIs for other languages.In conclusion, our study provides a practical overview of the challenges and considerations associated with localizing GUIs for RTL languages. We identified several key areas, including cultural values and design preferences, typographical considerations, and RTL-compliant GUI components, that organizations must consider when localizing their software for RTL languages. Our findings are valuable for organizations looking to expand their reach into RTL-speaking markets and provide a unique and culturally appropriate user experience for their customers. The global market's value for RTL-speaking users continues to grow, making it more important than ever for organizations to focus on developing culturally and linguistically appropriate GUIs.

Context: The growing complexity of modern web and mobile applications, shaped by rapid UI/UX advancements and agile software development practices, demands efficient and automated recognition of graphical user interface (GUI) elements, as manual testing remains costly and time-consuming. Objective: This study aims to evaluate the performance of the YOLOv8 deep learning architecture for accurate recognition of diverse GUI components, such as buttons, fields, headings, links, and images, from real-world application screenshots. Method: A small YOLOv8 model was trained on the Roboflow GUI element detection dataset containing over 1,000 annotated website screenshots, using 35 training epochs, a batch size of 8, and an image resolution of 640×640. Results: The model achieved measurable improvements, with precision rising from 0.368 to 0.454, recall increasing from 0.296 to 0.425, and mAP50–95 improving from 0.101 to 0.232. Strongest detection was observed for buttons and input fields, while weaker performance was noted for iframes and labels due to their inherent ambiguity. Conclusions: The results demonstrate that YOLOv8 has significant potential in automating GUI recognition, reducing reliance on manual testing in agile workflows, and improving interface validation. Further optimization with larger datasets and advanced augmentation methods is recommended to enhance robustness and generalization

In recent times, software industry has seen the immense expansion in its popularity. Graphical user interface (GUI) is of the most important and ground breaking factor behind the exponential growth of acceptance of software systems. Beside this popularity, software organizations are trying best to optimize the quality of delivered products. In software development life cycle, software testing is one major phase having focus towards improved software quality. Increased attention towards GUI in development helped in materialization of GUI testing as a vital branch of software testing. Manual efforts to test GUI have revealed a lot of problems, which, ultimately led towards automation of GUI testing. This paper presents a novel approach towards automation of GUI test coverage analysis based on an evolutionary algorithm, Particle Swarm Optimization (PSO). Another objective that has been tried to achieve is keeping number of test cases at minimum side.

This paper introduces graphical user interface (GUI) modelling approach and it positions in information system (IS) development process. The overview of graphical user interface design methods and methodologies is presented. The main objective of the proposal is the consistency of IS development process, which includes requirements specification, system design and implementation phases. The GUI modelling process is based on the data flows specification. Detailed explanation of modelling steps is presented. Paper includes an illustrative example of the web based GUI development according to the proposed process.

The purpose of the present thesis is the development of a first aid system, that includes an Android application for the end user and a Web Service for the communication with the database. The application contains information on providing first aid regarding the emergency, as well as the capability of persisting the user’s location on the database in order for special assistance to arrive. The application does not communicate directly with the database, but the Web Service ensures this communication as an intermediate. For the development of the aforementioned software, full-stack technologies needed to be studied, meaning, ones that provide the capabilities of developing all functions, starting from the front-end, the user’s graphical interface, all the way to the back-end, the communication with the database and the data transportation. For the user part, as mentioned, an Android application was decided to be developed. The Web Service software uses the REST architecture for the communicaton with the database and lastly for the storage of the data the Google Firebase platform was chosen, which among others services, provides a non relational database. The data are saved in JSON format and are available in real time.

One of the current approaches to software engineering is Component-based Software Engineering (CBSE). As its name implies, CBSE has to do with the development of open and distributed systems by assembling a set of components. However in practice it is difficult to follow the characteristics demanded by this working philosophy because when developers want to update or modify a component, they do not have the required and sufficient information to determine the degree of impact that a change will have. In order to understand the management of components in CBSE ten experts in software development were interviewed. With the information obtained, the requirements for a system that we call Component Presence Notifier were defined. This system supports the extraction of information from different repositories of the organization and presents it as elements of a graphical user interface (GUI). This information is provided to the developer while working with any of the registered components in order to increase his/her awareness of the impact of the proposed modification. As future work, this prototype will be evaluated for usability by a group of distributed software developers.

PurposeThe purpose of this study is to develop software for measuring the detectability index (d′) automatically from ACR 464 CT phantom images.MethodSoftware for measuring d′ automatically was developed with Python 3.9.13 using the PyQt5 graphical user interface (GUI) as part of the IndoQCT platform. The task‐transfer function (TTF) and noise power spectrum (NPS) were automatically measured to obtain spatial resolution and noise texture information. The task function was defined with a Gaussian and flat types, a matrix size of 300 pixels, a pixel size of 0.05 mm, and a contrast of 15 HU. The task object diameter was set to 5 mm for the tube current and kernel type variations, and ranged from 1 to 15 mm for the object diameter variation. The task object contrast ranged from 1‐29 HU for the object contrast variation. Each dataset was evaluated in terms of the d′ using the non‐pre‐whitening (NPW) model observer. Images of an ACR 464 CT phantom scanned using a GE Revolution EVO scanner with tube currents of 80, 100, 120, 140, 160, and 200 mA and kernel types of Standard, Edge, Lung, and Soft were used for evaluation. The results of our developed software were compared with ImQuest results.ResultsIn general, our developed software produced d′ values that were in strong agreement with ImQuest across all tested variations and both task function types (Gaussian and flat). For tube currents, an increase in tube current consistently increased the d′ value (r = 0.98). Analysis of kernel types showed that the Standard kernel yielded the highest detectability, while the Lung kernel yielded the lowest. For variations in task object diameter and contrast, larger diameters and higher contrasts increased detectability following exponential (R2 > 0.99) and linear trends (R2 = 1), respectively. Across all variations (kernel, object diameter, and contrast), the correlation between IndoQCT and ImQuest was exceptionally strong (r > 0.98), validating the performance of the developed software.ConclusionSoftware to automatically measure the d′ has been successfully developed. It is easily accessible with a straightforward, fast, accurate, and intuitive workflow.

Automated testing in web applications is becoming increasingly popular due to its cost-effectiveness, efficiency, and repeatability. Ensuring the quality of such software is vital, especially in scenarios where business requirements are uncertain and volatile. In this paper, we propose Cytestion, a tool that automatically explores a web application’s Graphical User Interface (GUI) to detect faults that cause visible failures, such as crashes, errors, and unexpected behaviors. For that, it applies a scriptless and progressive approach. To work as an oracle, Cytestion evaluates the output of each test case execution by considering the HTTP status of server requests, default and customized failure GUI messages, and console failure messages. We evaluated the effectiveness and cost of our approach in two empirical studies. The first study works with injected faults in open-source projects, while the second is a case study on eight industrial projects. Cytestion detected several faults in both studies and outperformed a state-of-the-art GUI testing tool.

Dynamic Robotic Process Automation (RPA) is an emerging form of business process automation technology that utilizes software robots or artificial intelligence (AI) workers. Unlike traditional workflow automation tools, where a software developer creates routine actions to automate a task and connect to the backend system using internal application programming interfaces (APIs) or dedicated scripting language. In simple terms, RPA systems observe users performing tasks within an application's graphical user interface (GUI) to create a list of actions, and then automate these tasks by replicating them directly within the GUI. This approach can reduce the complexity of automation implementation in products that may not have been designed for this purpose.

ObjectivesSince their introduction, electronic International Standards for Neurological Classification of Spinal Cord Injury (ISNCSCI) calculators have evolved to powerful tools providing error-free ISNCSCI classifications in education, research and clinical practice. For increased accessibility and dissemination, a multilingual support is mandatory. The aim of this work was to setup a general multilingual framework for the freely available ISNCSCI calculator (https://ais.emsci.org) of the European Multicenter Study about Spinal Cord Injury (EMSCI).MethodsThe graphical user interface (GUI) and PDF export of the ISNCSCI worksheet were adapted for multilingual implementations. Their language-dependent content was identified. These two steps called internationalization have to be performed by a programmer in preparation of the translations of the English terms into the target language. This step following the internationalization is called localization and needs input by a bi-lingual clinical expert. Two EMSCI partners provided Standard Mandarin Chinese and Czech translations. Finally, the translations are made available in the application.ResultsThe GUI and PDF export of the ISNCSCI worksheet were internationalized. The default language of the calculator is set according to the user’s preferences with the additional possibility for manual language selection. The Chinese as well as a Czech translation were provided freely to the SCI community.ConclusionsThe possibility of multilingual implementations independent from software developers opens the use of ISNCSCI computer algorithms as an efficient training tool on a larger scale.