Background
Graphical user interfaces (GUI) are an essential part of modern
software, providing users with an intuitive method to access all of the
functionality offered by a program. A well-designed GUI guides users by,
for example, displaying relevant actions, adapting to user input,
providing info tooltips and other visual cues. Software developed for
research purposes, however, rarely includes a GUI, relying solely on the
command line interface (CLI). The CLI is appropriate for advanced users,
who can then quickly integrate new software into existing pipelines, but
it comes with a steep learning curve (that may never be overcome) for
non-technical users. CLIs are sensitive to typing errors, requiring
users to remember which command-line options need to be included to run
a program effectively. Moreover, command-line tools generally have a
single, well-defined function and therefore require additional programs
to view or post-process the output, further complicating their usage.
These issues may appear trivial, but, in practice, they dramatically
limit the number of potential users to those who are already comfortable
using the command-line.
GUIs make programs more user-friendly and ease the adoption of novel
computational tools. While the inclusion of GUIs is in the interest of
both developers and users, there is little incentive to code a native
graphical user interface. Many journals are dismissive of the scientific
contribution offered by more usable software and development teams in
academia tend to be constrained in terms of members \cite{Mangul2019}. A common compromise is to set up an online service where a
web interface is used to launch a CLI program on a remote server. This provides cross-platform, installation-free access to the software, but has many disadvantages: (i) it requires a web server, necessitating additional setup, programming and maintenance; (ii) it cannot be used offline; and (iii) it is limited by the fact that users need to share the available network and CPU resources. Furthermore, such web
interfaces tend to be based on basic HTML forms with little
interactivity to guide the users. While it is possible to develop more
sophisticated web interfaces, this requires extensive knowledge of web
technologies like CSS (Cascading Style Sheets) and JavaScript, and can
take a long time to develop.
Although it is considerably easier to implement a web service than a
native GUI, integrating multiple programs remains a challenge. Both the
web interface and the server side code needs to be built for a specific
CLI program. Moreover, most of the user input processing and related
code typically resides on the server that is hidden from the users. This
causes redundancy, because the web interfaces cannot be reused by
third-party developers for modification and therefore need to be created
from scratch. The issue could be addressed by standardizing
communication between a graphical interface and the underlying CLI tool. Some specification standards have been developed, like the Common Workflow
Language \cite{cwl} or the Galaxy tools XML \cite{Afgan2018}, that define how to describe a CLI program in a text file.
Scientific workflow management systems (e.g. Taverna \cite{Wolstencroft2013} or CWL implementations like Arvados \cite{arvados}) utilize this information to integrate external
programs and, in some cases (e.g. Galaxy), also for creating the
graphical interface elements. However, these standards are optimized for
building pipelines and therefore omit GUI-specific instructions. In
addition, setting up and running a workflow management system together
with its environment (e.g. a dedicated web server, system container or
virtual machine) adds unnecessary overhead when used only for creating a
GUI for a CLI program.
Here, we introduce Pline (“ Plugin interface language” ):
a specification for describing command line programs and their
interfaces, and a lightweight framework that uses these descriptions to generate interactive graphical user interfaces. By utilizing standardization and web technologies, Pline allows for creation of graphical user interfaces for command-line programs without programming, considerably lowering the bar to develop user-friendly software in science.