Cached accessibility-tree control and code-enforced verification for design entry through a desktop application's user interface

In de wereld van software bestaat er een hardnekkige kloof tussen hoe mensen met computers communiceren en hoe machines met elkaar praten. Mensen gebruiken grafische interfaces, waarbij ze op knoppen klikken en tekst invoeren in vakjes die op een scherm verschijnen. Machines geven echter vaak de voorkeur aan het spreken van een directe, gestructureerde taal, waarbij ze de visuele laag volledig omzeilen om commando's rechtstreeks naar de onderliggende code te sturen. Wanneer een stuk software deze directe taal mist, wordt het een "black box" voor automatiseringstools. Dit is een veelvoorkomende hindernis voor robotic process automation, een vakgebied waar softwarebots worden getraind om repetitieve taken uit te voeren door menselijke handelingen op een scherm na te bootsen. De uitdaging is tweeledig: eerst moet de bot de juiste knop of menuknop vinden in een complex, verschuivend landschap van vensters; ten tweede moet de bot weten of de actie die het zojuist heeft uitgevoerd daadwerkelijk heeft gewerkt. Zonder een directe lijn van communicatie is de bot in essentie blind, waarbij hij gokt of een klik op de juiste plek is geland of dat er een nieuw venster is verschenen zoals verwacht.

Een onderzoeker genaamd Tiago Miranda de Leao pakte dit probleem aan door een systeem te bouwen om een specifieke, complexe taak te automatiseren: het ontwerpen van keukenkasten met behulp van een populaire Windows-applicatie genaamd Mozaik Enterprise. Deze software biedt geen directe manier voor externe programma's om ermee te communiceren, dus moest het systeem van de onderzoeker volledig via de gebruikersinterface werken, precies zoals een mens dat zou doen. Het systeem werd ontworpen om de twee hoofpproblemen van automatisering op te lossen: controle en juistheid. Om de controle te beheren, besteedde het systeem eerst tijd aan het in kaart brengen van de volledeng strucutuur van de interface van de applicatie, waarbij een mentale kaart werd gemaakt van waar elke knop en elk menu zich bevond. Zodra deze kaart was opgesteld, stopte het systeem met zoeken en handelde het in plaats daarvan op basis van een gecachte lijst met coördinaten, waarbij er direct op de bekende locaties van de interface-elementen werd geklikt. Om de juistheid te beheren, gebruikte het systeem een visiemodel om een ontwerptekening te "lezen" en gebruikte het vervolgens strikte, vooraf geschreven coderegels om te verifiëren of de computer daadwerkelijk heeft gebouwd wat er gevraagd was. De code, en niet de kunstmatige intelligentie, nam de uiteindelijke beslissing over de vraag of het werk succesvol was.

De resultaten van dit experiment waren een mix van veelbelovende snelheid en significante beperkingen. Het systeem slaagde erin de interface van de applicatie in kaart te brengen, waarbij bijna duizend verschillende elementen werden geïdentificeerd, en slaagde erin de posities van ongeveer zeshonderd van hen op te slaan. Wanneer het systeem probeerde te schakelen tussen verschillende tabbladen in de software, was het verschil tussen het zoeken naar een tabblad en het klikken op een gecachte locatie groot. Het vinden van een tabblad via de standaardmethode duurde ergens tussen de negenentwintig en zevenenvijftig seconden, een proces dat telkens weer het zoeken door de interne structuur van de applicatie inhield. Zodra de locatie echter gecacht was, duurde het schakelen naar datzelfde tabblad minder dan een derde van een seconde. Dit toonde aan dat voor een stabiele omgeving, het onthouden waar dingen zich bevinden veel efficiënter is dan het telkens opnieuw zoeken naar hen.

De aanpasbaarheid van het systeem was echter fragiel. De gecachte posities waren gekoppeld aan de exacte grootte en vorm van het venster op het moment dat de kaart werd gemaakt. Als de venstergrootte veranderde, of als de schermresolutie anders was, zouden de gecachte coördinaten naar de verkeerde plek wijzen en zou het systeem falen. De onderzoeker stelde vast dat het systeem zichzelf niet automatisch kon herstellen; als de lay-out verschoof, moest de hele kaart vanaf nul worden opgebouwd. Bovendien controleerde het systeem niet of de klikken daadwerkelijk werkten. Het zou succes rapporteren, zelfs als de applicatie niet reageerde, omdat het geen manier had om het resultaat te verifiëren zonder opnieuw naar het scherm te kijken, wat het doel van het cachen teniet zou doen.

Het verificatiegedeelte van het systeem, dat controleerde of het ontwerp overeenkwam met de tekening, werkte in theorie goed maar ondervond hindernissen in de praktijk. Het systeem werd getest met vijfhonderd synthetische gevallen waarin fouten bewust in de data waren geïnjecteerd. In deze tests identificeerde de code elke beoogde fout correct, zoals ontbrekende kasten of verkeerde type apparaten, en gaf nooit een vals alarm. Het wees ontwerpen af die niet aan de vereisten voldeden. Toch, toen het systeem werd getest op echte, ongeprogrammeerde pogingen om kasten te bouwen, waren de resultaten minder duidelijk. Vijf geregistreerde pogingen om een volledig ontwerp te bouwen, faalden in een vroeg stadium, waardoor het proces stopte voordat het eindproduct geverifieerd kon worden. De logs toonden aan dat het systeem niet correct het aantal kasten kon tellen dat het moest bouwen, wat leidde tot een onmiddellijke stopzetting. De onderzoeker merkte op dat het systeem niet getest was op een breed scala aan echte ontwerpen, en de weinige geregistreerde echte pogingen waren incompleet.

De studie benadrukte ook de rol van kunstmatige intelligentie in dit proces. Het systeem gebruikte een AI-model om de ontwerptekeningen te interpreteren, maar de uiteindelijke beslissing over de vraag of de bouw succesvol was, werd overgelaten aan de code. Deze scheiding was opzettelijk; de code fungeerde als een strikte bewaker, waarbij ervoor werd gezorgd dat de interpretatie van de AI werd gecontroleerd tegen harde regels. De onderzoeker vond dat hoewel de AI de tekeningen kon beschrijven, de AI niet vertrouwd kon worden om de uitkomst zelfstandig te beoordelen. Het systeem was zo ontworpen dat als de AI een fout maakte, de code dit zou opvangen. De gegevens toonden echter aan dat het systeem in de weinige echte pogingen al faalde voordat het zelfs het stadium bereikte waar de beschrijving van de AI werd vergeleken met het uiteindelijke resultaat.

Uiteindelijk geeft dit werk een duidelijk beeld van wat mogelijk is bij het automatiseren van software die weigert direct met machines te communiceren. De aanpak van het één keer in kaart brengen van de interface en vervolgens handelen op basis van die herinneringen is snel en effectief, maar het is broos. Het werkt alleen zolang de software er exact hetzelfde uitziet als toen de kaart werd gemaakt. Het systeem bewees dat controles afgedwongen door code betrouwbaar resultaten kunnen verifiëren, maar het toonde ook aan dat zonder een robuuste manier om om te gaan met veranderingen in de interface of om te herstellen van fouten, de automatisering de mens in een dynamische omgeving nog niet kan vervangen. De onderzoeker concludeerde dat hoewel de methode werkt voor een specifieke versie van de software op een specifieke machine, het geen algemene oplossing is voor alle applicaties. Het systeem blijft een proof of concept, dat aantoont dat automatisering mogelijk is zelfs zonder directe toegang, maar het onderstreept ook de moeilijkheid om dergelijke systemen robuust genoeg te maken voor de echte wereld.