Automation of Emulation-backed Create-View

Emulation services for direct user access often require more effort than simply providing the appropriate emulator and system image. Usually, the average visitor to memory institutions is not familiar with past computer architectures and their operating function. Thus, our goal is to research different approaches to creating automated access to the different digital artefacts users may request. The research surrounding emulation as an access strategy is progressing. However, there is still a lack of studies for the systematic use of different kinds of digital objects in their original environments. If a user wants to gain access to a digital object of a certain type, he needs to know how to transport the object into the emulated environment, how to initialize the operating system in the emulator, start the appropriate application and how to manipulate the object in the application.

Therefore, an emulation-backed create-view service should “mimick” the expected behaviour of loading the desired object for rendering or execution. This would be the clicking on an object and starting an “automagic” loading into the proper application from the computer’s desktop or from a web or file browser. This automation should assist the average reading room machine user who is unfamiliar with past GUI concepts and applications ((and the emulation (or rendering) process)). Emulation procedures are relatively complex compared to the use of modern file types. The object is to be wrapped and transported into the original environment, e.g. by attaching it via a virtual hard disk to the emulator. Thereafter, the emulator containing the original environment must be activated and the object loaded into its original creating or viewing application.

There are different ways to achieve automated access. The approaches range from altering the original environments to automatically interacting with them, thereby replacing the human user.

Introducing small applications or scripts into original environments

Kam Woods and Geoffrey Brown describe in “Assisted Emulation for Legacy Executables”, a software designed to minimize dependence on this knowledge by offering automated configuration and execution of emulated environments. The group at Indiana University demonstrated simple scripts using AutoIT GUI automation for Windows operating systems in order to install applications on demand. The approach was tested on different applications in several Windows versions. The authors used VMware virtual machines during application implementation. They “… show that with a small amount of coding – less than 600 lines of C# code to guide the user, configure an emulation environment, and run associated install scripts, and less than 100 lines of Java to link browsing of a web archive to the local application,” they “… can create stable, repeatable environments for virtually any application type. Typical object-specific install scripts are small (1-10 lines of code).” This approach requires some more in-depth knowledge of the operating system and is dependent on a subset of X86 operating systems. The virtual machine used during the experiments should be replaceable with QEMU for long-term access.

Using low-level Original Environment Automation Options

A somewhat similar approach using different tools was tested Freiburg University for the Bachelor Thesis “View-Path Realizations for Obsolete Digital Objects”. It looks into options of automation procedures provided by the original operating systems and applications. This includes the preparation of special start scripts like the AUTOEXEC.BAT or the provision of autostart for the required application. This approach uses pre-configured system images for different emulators or virtualization tools. The required applications are pre-installed to separate hard disk images, possibly allowing for an easy recombination of operating systems and applications. In order to achieve this, the primary hard disk containers are modified on startup by adding files to them. This can be done by mounting the containers from within the host operating systems, if the container structure is understood and the filesystem supported. Another option is to run scripts within the original environment on startup to copy files from secondary sources such as secondary hard disks or optical drives. The approach follows the view-path / pathway model to a certain degree. It decides (automatically if a proper file type registry is available or with user interaction of possible options) on the application from the object type. The application requires a certain operating system which itself could run in a certain emulator. The approach does not require special additional software and could be applied to a wide range of operating systems and emulators. It was tested on DosBox, QEMU and Virtual Box mostly for office documents requiring applications running on DOS or Windows operating systems.

Abstract Automation of User Interaction

Beside altering the system images or introducing special tools into original environments, this approach applies automated application procedures, also known as Migration-by-Emulation. It depends on a VNC interface in the emulator in order to run unattended interactive environments. This approach requires the recording of mouse and keyboard inputs for actions such as launching the operating system and appropriate application to deal with the artefact once. These recordings are then repeated on other objects of the same type, migrating them automatically into the same output format.

The same mechanism should be applied when preparing the original environment of the user in order to avoid the need of any specific operating system or application knowledge. The system should be developed in a way that is abstract enough to handle arbitrary environments and emulators. Besides the automatic loading of an average text document into a certain application, the concept could be extended to run the first steps of a computer game like Monkey Island (LucasArts) unattended before handing it over to the user. The challenge is a bit different to the Migration-by-Emulation implementation as the control is to be handed back to the user after a certain point. This approach is currently being research at Freiburg University for a Bachelor student’s thesis.

By Dirk von Suchodoletz, posted in Dirk von Suchodoletz's Blog

7th Oct 2011  10:29 AM  11527 Reads  No comments

Comments

There are no comments on this post.


Leave a comment