Develop from anywhere
Digital nomad developers and those aspiring to be will appreciate these tips for practices that will keep you productive while on the road, or simply if you prefer digital minimalism.
It was well over 20 years ago that I started teaching myself the rather new-at-the-time craft of web development, and decided to make a go of starting a business out of it.
Aside from loving working with the technology, a driving force behind this decision for me was to create for myself a flexible lifestyle to pursue other passions outside my career.
I quickly learned that neither business nor software development are as conducive to creating spare time as I had hoped they would be, but I never lost sight of that driving force and have continued to experiment with different approaches that avoid my work dictating where and when I spend my time.
Following are some of the practices that have had the most success at achieving these outcomes.
Minimise using tools at your workstation that you can't take with you
My workstation once consisted of a beefy custom desktop PC with articulated arms supporting everything from three monitors to a boom microphone. It was an impressive setup for the time, and one that I was both proud of and very comfortable working at.
Fast-forward a few years, and it consisted of a Surface Book sitting on a repurposed monitor arm at a standing desk, with a screen projected on to the wall.
These days I use my android phone (a Samsung Galaxy Fold 4) connected to a Bluetooth keyboard and mouse with a pair of AR glasses.
My journey to a minimal setup wasn't because the full-featured setup didn't make me more productive. It certainly did. Sometimes I miss not having to ctrl-tab back and forth between the code editor and browser, or being able to have a dozen desktop apps running and visible at once.
I moved away from the desktop workstation because I've always hated being chained to a desk. Even the act of grabbing my 15" MacBook Pro and heading to a café felt like a significant downgrade and a shift enough in my workflow to be jarring and unproductive. Travelling interstate for a few days to visit clients could feel like torture.
The move over time to the Surface Book and projector offered a lot more flexibility. I used the Surface Book in its many different modes for development, and I used the projector for the meetings which often filled my day. When in meetings I could stand and walk around the room, and if travelling I could often replace the projector with a hotel room TV.
This setup still bothered me, though. While the Surface Book is a portable machine, dragging it around constantly was neither good for my back, nor for the machine itself. And when it eventually failed on me the several times it did, replacing or repairing it was a difficult and expensive process that left me unable to do my work for weeks at a time.
Further, laptops - despite their name and the ideals they represent - are really only suited for working at desks for all but the shortest of periods. Desks aren't always available, and when they are, you don't necessarily want to be sitting at one for any length of time.
If you are the kind of developer who prefers to keep their work to their workstation and nowhere else, then I'm all for the biggest and best setup money can buy. But if, like me, you don't like being tied down to one place to do your work, then a robust set-up will by its nature do exactly that; because anything less than what you are used to working with daily will be a painful transition.
Whatever you are comfortable working with in a café, at a hotel, or laying in bed is what you should aim to use daily. I'm not saying that this needs to be a tablet or a phone either - if it's a laptop, then use a laptop. Just aim to keep to the lowest common denominator where possible.
And use bigger tools when and if you need them for short periods of time - short enough to avoid forming habits. I still have my Surface Book and pull it out on the increasingly rare times that I can't work out how to do it from my phone.
Use a code editor rather than an IDE
Full-fledged IDEs such as Visual Studio or JetBrains' many offerings are magic.
Or more correctly, as Arthur C. Clark stated, "Any sufficiently advanced technology is indistinguishable from magic."
The IDE isn't actually performing magic, of course. The work that they automate is sufficiently abstracted from you that you no longer fully grasp what is happening behind the scenes.
I saw this as a common issue with .NET developers who - almost without exception - used Visual Studio to do their work. Visual Studio has arguably always been a forerunner in IDE magic, given that the development framework, the language, and the IDE are all built by the same company.
When you hit the F5 button in Visual Studio, your app builds, starts and appears on your screen, without the need to configure project files, build scripts or dependencies. While all these are still there, the IDE works so well you rarely have to think about them.
Unless something went wrong.
I've seen many .NET developers (myself included) simply staring at an MS Build error on the screen in Visual Studio, clueless on what to do next to resolve the issue, simply because the IDE trained them to not ever otherwise think about it.
Fortunately, with the onset of .NET Core and later frameworks, this is less of an issue within the .NET community, but the principle still applies. As a developer, you should at least understand the purpose and structure of every file, script and command used within your project, and preferably be comfortable editing or using them manually.
A code editor forces you to do this in a way that an IDE won't.
Code editors are, due to their lightweight nature, generally more available across many different operating systems. They are also faster and less resource hungry (assuming you don't overburden them with extensions) than their IDE counterparts, meaning that they can be run on significantly less powerful machines, and in some cases even in the browser (VS Code) or terminal (VIM, Emacs).
A good code editor can be enhanced through extensions to a point where they will do much of what an IDE can do, but you get to choose what you need to support your workflow.
Use development containers
Even without running a resource hungry IDE, you still will need the specs to be able to run and test your application, along with the applications and frameworks required to support it.
However, it is arguably wasteful and unnecessary for the computing power required to do this to be physically sitting in front of you. Certainly not, if you want to be sufficiently mobile.
Enter cloud development environments. With this practice, instead of working with your code on your local machine, you use your local machine as a user interface for your development environment that is running on a remote machine. Think of this as the development version of cloud or remote gaming. You rent the time you need on a more powerful machine that you then don't need to carry around with you.
There are a number of services that package this up for you. GitHub Codespaces and GitPod are two such offerings, but you can also host development containers on your own servers or locally.
Aside from allowing your local device to become more of a lightweight thin client (and therefore more mobile) development containers offer a bunch of other advantages, such as dedicated environments per project that avoid versioning issues between projects, rapid deconstruction and reconstruction of an environment when things go wrong, and faster onboarding when working with teammates.
The downside of remote development containers when mobile is that they require a consistent Internet connection to be able to connect to them. Let's face it, though, coding by itself without access to the Internet is rarely a productive venture. A less than stable Internet connection is much easier to manage if you can work using a terminal or browser...
Learn how to use the command line
When considered with the practices listed above, this makes more sense in the context of developing on-the-go than it otherwise would.
Terminal environments are ubiquitous (even on Android with an emulator like Termux), lightweight, consistent across machines, and require significantly less bandwidth for remote connections than, say, VNC or RDP.
Most development frameworks and IDEs simply trigger command line tools behind the scenes to do the work, so if you can become familiar with these commands, you can do most of the work that an IDE does directly without the use of an IDE.
Many tasks, from checking out a git repo, scaffolding a project, or launching a GitHub Codespace are faster when done from the command line than loading up a GUI and clicking through options.
Even Android or IOS applications can be built using a command line, mitigating the need to run a full-blown instance of Android Studio or Xcode to do the same. All meaning less dependence on hefty machines or fast Internet.
Use browser-based tools
For the same reasons you want to use the command line, you also want to lean towards browser-based apps rather than those that are locally installed. Extending the thin client concept already discussed, the modern web provides a consistent and standardised UI to server-based computing that is available everywhere, and can be accessed by the least powerful, smallest and cheapest devices available today.
Coding within the browser is more than feasible with tools such as VS Code for the web, AWS Cloud9, and CodePen.
With little dependence on local apps, switching machines is often not much more than opening a web browser on the new machine. Perfect if you often switch between working at a desktop, laptop, mobile device or even a VR headset.
Learn keyboard shortcuts and touch typing
Unless you are comfortable working with a laptop trackpad, one of the first pain points you discover when stepping away from a desktop workstation is using a mouse.
Aside from the plentiful advice on why you should generally avoid using a mouse while coding, learning to become less reliant on a pointing device makes using a wider array of devices much easier to use. Working on portable devices such phones, tablets and AR/VR headsets is considerably more comfortable when avoiding using a mouse and from looking at the keyboard.
Use VIM emulation
An extension of learning keyboard shortcuts is learning the VIM keyboard editing layout. VIM is a terminal-based text editor. It is available or installable on practically any device, and there's a good chance that it is older than you are.
Because of VIM's history and availability, most code editors and IDEs offer options and extensions to enable VIM emulation to edit code. Meaning, that you can switch between editors and environments at ease without needing to learn a bunch of new keyboard shortcuts.
VIM enables powerful code editing without the need to touch a mouse, or even reaching for the arrow keys on the keyboard.
VIM also goes hand-in-hand with learning the command line. VIM itself, neovim or Emacs with evil mode is often present on many machines, and with a bit of configuration, can be used as a full-featured code editor.
VIM modes are unique and are known to have a bit of an early learning curve. There's an abundance of help available online to start learning, though.
Use AR glasses
While not technically a development practice, the biggest impact on my mobility has come through first adopting the use of a VR headset and then eventually AR glasses.
Avoid using the AR part of the AR glasses, and you'll find that devices from XReal and Rokid in their simplest form project a 1080p huge monitor into the air in front of your face, no matter where you are.
I use XReal Air with Samsung DEX, a keyboard and mouse to get a full desktop experience using my phone. However, they can also be used with a laptop, tablet, or even a steam deck to provide a comfortable workspace from a café, bed, plane, bus or by the beach.