Like any task, developers depend on the right tools to get the job done. The tools available range from incredibly simple to uniquely complex. No matter where your developers fall on the spectrum of difficulty, there is a tool for them.
IDEs, editors, compilers, and version control systems all enjoy powerful and flexible graphical applications, more information you can find at bairesdev.com.
That doesn’t mean, however, your developers must work with a GUI. What happens if one of them is tasked with developing on a headless server with no GUI? What do they do then?
Fortunately, some tools make it possible to develop without a GUI. And although you might think such tools are limited to the Linux operating system, you might be surprised to find out that even macOS makes it possible to develop without a GUI.
But what are the pros and cons of developing without a stack of graphical tools? Let’s dig in and find out. Before we continue, understand this isn’t about developing non-GUI-only applications. Rather, this is about developing any type of application without using GUI tools for the process.
First, let’s examine the pros.
Better Understanding of How Things Work
When you develop from the command line (without a GUI), you gain a much richer understanding of how things work. This is partially due to the fact that your tools are doing everything for you. Because you have to manually write, compile, format, debug, and recompile your code, you will eventually come to have a deeper understanding of the software lifecycle.
Any time you can learn more about how all of the pieces come together, you’re a step ahead of the competition. So working without a GUI shouldn’t be considered a hindrance, but a help.
Fewer Hardware Requirements
Some graphical IDEs require serious hardware to run. Some IDEs will bog down a computer come compilation time. That’s not the case when doing so from the command line.
This means you can work from lesser-powered hardware, which can be a real cost-savings for some businesses that cannot afford to constantly purchase new hardware due to an IDE’s ever-increasing requirements.
Although, at some point in the software lifecycle, you will have to use a GUI for testing those graphical applications your company has developed. But stripping away the GUI during the development process can be a real boon for those looking to cut hardware costs.
Work More Efficiently
If your developers are looking for a way to increase their efficiency, working without a GUI might be just the ticket. Sure, you might think adding layer upon layer of automation to those graphical tools is the best route to speed, but pounding keys, using keyboard shortcuts, and leveraging the power of commands can bring about a serious increase in inefficiency.
Because your developers will better understand the process, and manage to keep their fingers on the keyboard, they’ll be able to better focus on the code and less on the tools. Granted, they will have to have a bit more skill to make it work, but once they’re up to speed the sky’s the limit.
Easier Remote Work
There are times your developers might have to secure shell into a remote server to do development work. This server might be in your data center or maybe a third-party cloud host. Either way, if you want them using a GUI served up from a remote server, you’re looking at considerably more effort on your part.
When your developers can work from the command line, they can work remotely with ease. SSH into that server and start hammering away on the keys to further the software development lifecycle.
This one is simple: You don’t have to pay for GUI tools that can get costly. This is especially true when you’re having to purchase software for larger teams of developers. When developing from the command line (without a GUI), most of the software your developers will use is open-source, so it won’t have an associated cost.
If your business is working on a very tight budget, a free (or nearly free) software development lifecycle (minus paying your developers, of course) is a very attractive proposition.
But what are the cons? There are three you must keep in mind before you consider tossing those GUIs to the curb. Let’s take a look.
Steeper Learning Curve
This is the deal-breaker for many. Getting rid of the GUIs for development isn’t easy. There are a lot of commands to learn and the process becomes more and more complicated.
In some cases, you even have to spin up the development environment before writing that first line of code. That’s even more commands to learn. In fact, every step of the way will be focused on commands.
And, to make things more complicated, your developers might wind up using a tool like vi, vim, or emacs as an editor. Anyone that’s used one of these tools understands that with such power and flexibility comes complexity.
Along with the steeper learning curve comes more work. Instead of benefiting from IDEs doing a portion of the work in the background, those who develop without a GUI must do all of the work themselves. If your developers don’t have time for the extra load this will place on their workday, a GUI-less environment might not be the best option.
More Challenging Integrations
Finally, if your development teams benefit from tightly integrated tools (such as IDE integrations with the likes of GitHub), they might find working without a GUI too much of a challenge.
Yes, you can integrate the command line to a GitHub, but it does require a few extra steps and nothing is automatic. When seamless integrations and speed are key, a GUI-less development environment might not be the best route.
In the end, the decision is on the stakeholders’ shoulders. If your developers are up to the task and need to work with heightened efficiency (and your business needs a lightning-fast development lifecycle), working without a GUI can be a great software development path. If, on the other hand, your developers aren’t up to the task, removing the GUI can be a real hindrance to progress. Choose wisely.