Three Reasons Why You Should Wrap Legacy Codes in GUIs

Most often, scientists develop code that runs locally on the command line. Meaning, a user interacts with the computer via commands given in text form, rather than using menus or graphics.

Command-line interfaces (CLIs) can be difficult to learn for novices. There are no visual cues; one must recall what the system can do and the commands to make it happen. To get them up and running, confusing text input files are also needed.

One solution to making knowledge transfer easier, onboarding processes faster, and collaboration less cumbersome? Wrap your command line code in a graphical user interface (GUI). GUIs have the advantage of being easy to use and simple to learn, which opens a code up to a wider group of users who get up to speed faster.

In this post, we cover three ways GUIs improve productivity and business outcomes.

1.   Better succession planning

Frequently, mission-critical scientific codes have one expert—the code author. But what happens when that person moves on to another project, retires, or otherwise becomes unavailable?

Companies and labs can be left scrambling.

This is where good succession planning can make a big difference. If you have a simple, quick way to transfer legacy code resources and knowledge, everyone can get working faster. One way to do that is to wrap that important code in a GUI.

GUIs are simple to learn and don’t require advanced or specific coding knowledge. This means that learning and using legacy code with GUIs can happen much faster than traditional command-line interfaces.

2.   Shorter onboarding processes

Another complication of single-person authorship is an arduous onboarding process. Teaching a new employee how to use a legacy code can mean weeks or more of learning before they can work independently.

If a project is time-sensitive, that onboarding could run longer than the project itself. This also adds cost because two people are working (teacher and student) when one trained person would suffice.

For example, say a summer intern is assigned to work on a project requiring the use of a legacy code. Even if they are familiar with coding, it can take weeks to get them up to speed on a particular legacy code. That means one or more people teaching that intern the ropes, adding cost. By the time they can work confidently, the internship could be over.

GUIs flatten the learning curve when compared to command-line interfaces, reducing onboarding time from months to days.

This is largely thanks to their visual nature. You don’t need to memorize commands for GUIs. You don’t need to be fluent in coding language for GUIs. Graphical interfaces allow complex systems and/or processes to be reduced to simple-to-execute actions. (This feature is especially useful since legacy codes often lack proper documentation.)

3.   Ready-made plots

Command line codes do not automatically produce graphical plots or other visuals. This means that after the code is run, the user must take multiple additional steps to produce a plot, increasing overall task time.

GUIs can be programmed to automatically produce plots in the same program. Reducing the time spent running ancillary plotting programs, and improving overall efficiency.

GUIs open legacy codes up to a broader community

Simply wrapping a legacy code in a GUI can solve major problems impacting your business right now by making people productive faster. It makes getting consistent visualizations straightforward, which can aid marketing efforts and improve ease of use. It also future-proofs your company, ensuring legacy code resources aren’t lost with staff transitions.

Bottom line, if you want to better your business in any of the above ways, it’s time to start thinking about wrapping your legacy code in a GUI.