Imago Dev

Reflecting The Creator

Code Editors Change Our Work


Since the beginning, man has been finding ways to extend the ability of the individual with tools. We began using tools to create more advanced tools. Over the millennia, our technology compounded on itself. With the invention of computer software, our tools vent virtual. The growth of software has exploded faster than practically any other toolset man has created. With that explosion has come the evolution of one of the core tools one uses in making software, a source code editor.

Evolution of Editors

I first learned to code about 10 years ago in a high school course. Other than using Notepad for the first program or two, we used Turbo C++ by Borland. Looking at the interface now, it seems quite ugly and dated, and to be honest it looked dated even then. Once you get past the over-saturated blue editor pane and drab grey tool bar, you find a fairly decent integrated development environment for a beginner. It compiled and executed the code, syntax highlighted keywords, showed where compile time errors were located, and had a debugger to step through the code during runtime.

In just the decade since I used Turbo C++, source code editors have grown substantially in their ability and scope. I have used a number of editors over the years, now landing on VS Code for web development and Intellij IDEA for Java, Scala, and heavier Javascript work. It is almost hard to believe how advanced these tools are when compared to Turbo. Between the huge number of features that come built into the editor and the vast array of extensions available, the software developer has everything all in one comprehensive tool.

Speed & Flow

Putting all of the features a developer needs into one tool can drastically increase productivity. Powerful search functionality allows jumping to disparate sections of code in an instant. Refactoring convoluted components can be done with a click of a button. Building, testing, and deploying can be kicked off with a single hotkey.

There is no doubt that source code editors have come a long way at supercharging the development process; however, one must be careful about speed for speed’s sake. Simply creating code faster, if not the correct code solving the correct problem, only puts you down the wrong path even quicker. The latest tips and extensions for your VS Code setup is not going to solve your poorly designed application architecture.

Assuming what you are building and how you are building is sound, the less friction the developer runs into while constructing the better. Not only does the problem get solved faster, but the developer can think clearer with the limited amount of cognitive load. The less you have to think about superfluous tasks like how to build or where a function lives, the more you can focus on the real problem.

Getting to the point where editor creates this speed and flow can take some up front investment. Advanced editors like Intellij can be so vast that knowing where the feature you need resides takes some searching. The editors may also require some third-party extensions for it to handle your project well. Even the most basic editors, like Vi, take deliberate effort to learn how to maneuver. Thankfully, many great tutorials exist, often by the editor’s creators, on how to master these powerful tools.


I suppose it is tempting, if the only tool you have is a hammer, to treat everything as if it were a nail. -Abraham Maslow

Tools change how we look at a problem. When used optimally, tools can make a task easier; however, a limited idea of when a tool is best used can cause us to approach the problem in the wrong way. This may not only make solving the problem harder, but cause additional problems. It is because of this importance that we must take the time to learn about our tools, both how to optimally use the ones we have and what other tools are available.

Source code editors are no exception. With such a powerful tool that every developer will spend a vast amount of time using, these tools have a great impact on the resulting application.

How does your editor effect your work?