Coders, what is your workflow on Linux

• Code in VSCodium
• Code in Kate to keep thing fresh
• Code in Nvim because I still need to learn it
• Cry while debbuging a React app because the error messages aren't very good
• Wish I were working with Svelte or had enough backend experience to switch to being a backend dev
• Play with terminal configs and shell scripting to distract myself from my woes
• Rinse and repeat.

Aside from the (not so much) jokes, give VSCodium a try, it's to VSCode what Chromium is to Chrome, and works just as well.

Am I the weird one that just uses jetbrains for everything?

I'm an old school emacs guy, I prefer that for c++/python/etc and run KDE Neon because I like KDE and I'm used to ubuntu (and Kubuntu has some issues). For c++ I use CMake, google test. Not really a fan of docker etc. but I have used Kubernetes and docker in the past. Those types of containers just create new and more complicated problems than just testing on the target platform, but in some niche cases it can be useful.

I can't stress enough how awesome emacs is, but it takes a serious investment to get efficient with it.

1. Code in Emacs
2. Create a Nix Flake for building my Environment
3. Build with whatever buildsystem the language requires, often Stack or Cargo
4. Package for nixpkgs

Tmux + nvim for editing code and bspwm for a fully keyboard only workflow. I have some keybinds in tmux to open a new pane and run cargo or whatever command is necessary to run the code.

Transfer the app through scp [...]

I use an ad-hoc while loop in a shell with inotifywait to wait for changes in the watched directory and then scp it.

arch with vsc or jetbrains

Neovim for me. There are so many plugins to make the editor behave exactly as you want.

I'm also running Ubuntu as my main machine at home. (I have a Mac and do Android development for my day job).

But at home, I do a lot of website and backend dev.

1. Code in VSCode
2. Build using docker buildx
3. Test using a local container on my machine
4. Upload the tested code to a feature brach on git (self hosted server)
5. Download that same feature branch on a RaspberryPi for QA testing.
6. Merge that same code to develop 6a. That kicks off a CI build that deploys a set of docker images to DockerHub.
7. Merge that to main/master.
8. That kicks off another CI build.
9. SSH into my prod machine and run docker compose up -d

I usually hack stuff together with vim and tmux (I know, it's redundant but Ctrl b is just a reflex at this point) when on a remote machine, but I use vscode at work and recently discovered the remote mode for Linux development... It's pretty awesome, like not anything you can't set up with vim or emacs, but it's seamless remote development if you already like to use vscode

I'm the only Sublime Text guy here, I guess. Mostly with extensions for formatting, linting, and detecting compilation/type errors. I work with all kinds of languages, mostly interpreted. Python, Rust, Bash, JS/Typescript, Solidity, and a smidge of others so it's hard to pin down one workflow.

EDIT: Just wanted to add that it's really cool to see the diversity in the replies. This here is the power of Linux.

I work with backend web development, so running code could not be any easier, normally there's a docker image setup watch for changes, recompile and execute.

My text editor is Kakoune, after learning the keybindings I just cannot go back to vim or vscode, selection based editing just makes so much sense to me.

I use NixOS, which comes in handy for keeping my home and office computers in-sync. I also use nix shells to declare the tools necessary to develop each project.

As for window management I use sway, one big window for kakoune to the left, other terminals for docker/tests/git to the right.

I mainly use Python, so my workflow is the same on every OS: Neovim and a shell, usually one of each in a vertical split. This transfers nicely to remote SSH sessions too, and even works in Termux on my phone!

Have you investigated whether it's possible to test your cross-compiled builds in Qemu, rather than copying them to the host?

1. Setup my vimrc.
2. Clone the project, and realize that whatever repo managing system they started using 3 years ago requires setup steps not in the README and breaks everything at the slightest touch.
3. Build the currently relevant project in whatever build system they started using 3 years ago (CMake is quite nice).
4. Fix my vimrc to be compliant with whatever tabbing they use.
5. Realize that for some reason, someone made a commit in the file I'm reading that uses 3 space tabs. And worse, someone approved that PR.
6. Make changes via vim.
7. Debug via print because setting up gdb or JTAG on embedded systems is usually more effort than its worth.
8. Realize it's a timing issue and reluctantly go find the JTAG debugger.

Rust and C development mainly with a bit of assembly language sometimes:

• Debian Stable with Xfce
• distrobox with podman for containers
• xfce4-terminal with tmux
• vim with plugins (coc.nvim, delimitMate, NERDTree etc)

I'm running Docker in Windows and have a mounted drive. I code in VSC using that mounted folder / volume, and the page shows up on localhost. Just a few simple apps to convert fixed width to csv's and back and gives analytics on the data using jStat and tables with dataTables. Nothing fancy, but I like it.

Edit: httpd 2.4 as the Docker container.

I vehemently dislike coding directly on my workstation and do all of my development in remote VMs via SSH, when possible. My work MBP is a glorified SSH terminal with a web browser. I got my start in the industry with remote SysAdmin stuff so, it feels pretty natural.

For an IDE, I use Neovim, currently with a plugin distribution - Neovim because I got used to the vim syntax as a SysAdmin and the distribution because I can't justify sinking more time into tuning my env for a bit but am intending to scrap it all around the holidays or so.

Most of my work is in Go or Python. At home, it's a mix of CircuitPython, C, and I'm picking up some Rust (mainly embedded for C and Rust). Will be starting to learn Verilog this weekend.

For Go and Python, I tend to lean towards a TDD approach, even if it gets a bit derided by coding streamers.

My workflow tends to be:

1. Prototype desired functionality to get at least individual parts working.
2. Start from scratch and rough out any classes/structs and test suite boilerplate.
3. Start the red->green->refactor loop, giving extra granularity to parts of code that I am less confident in.
4. Once all intended functionality is implemented, run manual tests (I generally develop tools).
5. Fix bugs that unit tests failed to prevent or I failed to anticipate.
6. Repeat 4 and 5 until acceptable.
7. Prepare commit.
8. Push commit and receive failure because I haven't fully configured my formatters to clean trailing whitespace and VT100-compatible line lengths.
9. Push commit again and send for code review.

Currently, my build automation is kinda in CMake. Really, the Makefile is just calling a build in a docker container.

For C, Rust, and Verilog, I'm not yet familiar enough to have yet established workflows.

ETA: I think I just got the same FPGA as you! Xilinx Zync-7020 (Digilent Arty Z7-20).

C and Lisp:

st -terminal

tmux -workspaces

vim -editor

vim-fugitive -git UI

make -did not require more power yet.

everything vanilla except some custom lines to have vim and tmux share the same pane/window navigation keys.

Hobbyist programmer. When I switched to Linux, I started using the Atom editor for typing out my JavaScript projects (mostly Electron apps). Now I use Pulsar, because Atom development was cancelled.

https://github.com/pulsar-edit/pulsar

I also find nvm to be helpful for installing and using Node in the terminal.

https://github.com/nvm-sh/nvm

I mostly program in Rust and my main editor is VSCodium with the NeoVim extension but lately I've been experimenting with Alacritty + Tmux + Helix and I'm starting to like it quite a bit.

I use helix on NixOS. I have the most basic setup for c(++):

• edit with helix
• write custom makefiles with a script I made
• test the program with the makefile
• debug with cout or printf

Java dev, running opensuse Tumbleweed with KDE.

IntelliJ IDEA, maven, git, postman

Kate for quick edits and note taking works very well

Konsole is my terminal of choice

Teams for Linux because I have to

docker on the command line because there's no docker desktop for Linux. There is for windows and MacOS tho, although Linux is literally the thing where it runs on the kernel and whose concepts the whole thing is based upon. Fuck them.

Kind of sad to see still lack (for Linux in general) of apps that are often used in companies. E.g. Teams and docker desktop

$mod+enter vim enter Ctrl+p [type a part of the name of the file I want] O [write code]

I mostly write rust now, but this workflow was finetuned over years. Use 2 terminals each on a diferent monitor, one runs neovim and the other is for building/running. If the project is a bit more complex, I will run it in a docker container( maybe mount the /etc/shadow and frieds so all artefacts are created using the same user as in the outside) . Developed a bunch of tools over the years to optimise this:

• a 'package manager' in bash so I have a folder for each project/context. One for work, one common, one for the server stuff like this. All are in PATH.
• parterm - remote control for the terminal so i can start a build from neovim in a different terminal.
• 'ndock' - at work I use a bunch of branches, this script will set up a few envs and then start a docker in a folder coresponding to that branch.

At my old job had to work on a remote vm so I setup sshfs for a while, but was slow and just moved all my tools there.

I have a pattern where i put all my projects in ~/dev/<project><branch> and all info related to a task in ~/dev/<project>/bugs/<issue_nr>. This is usefull because I can have scripts the work similar for different projects with small changes. For example to run my binary with the config for a issue i just do

ndock <branch>
nr <issue nr>

This will start docker or connect to an existing one for that branch if available, compile the code, run my binary with the config present in the bug folder. In the last few month started running it with rr to be sure i can debug any random issue.

1. Code in Emacs or Jetbrains (depends on language and laptop cpu)
2. Run make to build, run, debug, or clean (I like makefiles for documenting basic tasks)
3. Commit with git when chunk of work is done

I tend to do everything locally on bare metal. I never liked putting stuff in containers or running a vm.

VS Code is a great editor, though. It actually feels a bit like Emacs.

Neovim. I work in devops so it's terraform, ansible and aws cli right now... No need to compile anything or build anything. It's quite nice and simple. :)

The ability to do everything with shortcuts and no mouse means i get into a certain flow feeling that is really nice. When I need to web search, I use the mouse however. I don't like the vim like plugins for the browser. The mouse is way faster there.

Do Data Scientists count? I run Bedrock Linux with Hyprland WM and Alacritty as my terminal manager.

I use Jupyter Labs for almost everything. Then Emacs for anything else. I don't like the default config at all, and I'm not that well versed in elisp, so I use Doom Emacs.

I mainly write C. I really like Intellij Clion because it uses CMake as project files. It also makes tools like valgrind, perf and gdb available without having to go to the terminal.

i3wm/sway - lets me navigate windows with vim-like keyboard motions Neovim - best power editor, hands down. But it takes a bit of tweaking. Tmux - lets me have multiple terminals up in one window. Make/CMake/whatever the project uses. I also write scripts for anything that causes friction which can be automated. Vimium/VimiumFF in the browser - lets me navigate most webpages with just the keyboard.

I use Geany, so that's basically my whole workflow.

• kitty terminal emulator
• Vim for editing
• CMake for builds
• A shell script based around entr for automatically running the build/test cycle when I modify files

My workflow is: my neovim config is - at last - nearly perfect, quickly configurable for many languages on the go, nevertheless I don't code because when I get home from work I have barely the energy to play for half an hour.

For python:

• Pycharm with integrated git For web dev and game dev:
• vscode with GitHub desktop or integrated git, XAMPP if I'm doing back end

Mainly C++ with a sprinkling of Python and Rust for fun.

Used to code KDevelop, now VSCode. Build in a regular terminal (I prefer Meson over Cmake, both end up producing Ninja files.) Debug with valgrind, gdb and ddd. Push to Gitlab for my personal projects.

I use Docker for my test environments as it's easy to bring them up and restore them to mint condition, and it ensures that the longer running tests with side effects don't interfere with one another.

Neovim (with NvChad or the like) + tmux is great, once you figure out the keybinds. Probably not so great for debugging, though. VSCode is a good all-rounder.

Like many others I also use NeoVim, but it was quite a bit of learning curve before you get comfortable with it. And you really have to go all in and learn at least the basics, if you try to use it like a normal text editor thinking you'll learn commands as you go along then you're going to hate it.

In addition to having to learn how to use vim, you also need a good configuration and probably some plugins if you want to use it as an IDE. Personally I use fzf, coc, vim-dirvish, lightline, lightline-bufferline and papercolor-theme.

Code in VSCode

UI in QT Creator

Build with qmake

Commit with git

Push to GitLab

Run jobs with gitlab-runner

Deploy AppImage, deb, rpm builds with Docker

Helix + sway + nix-shell + git + sourcehut is a pretty tasty combo not gonna lie.

I tend to prefer Jetbrains editors (CLion, Rider, WebStorm) for projects, and just nano/micro for config editing and such...

1. Code in Nvim
2. At work we build using shell scripts, for personal stuff it's usually Make
3. At work, deploy with Jenkins to Kubernetes or through Puppet to real/vm hosts. a. At home, I use Ansible 99% of the time
4. Debugging?

• Sublime Text.
• Whatever build toolchain of the current thing I'm using.

I use IntelliJ IDEA for V and Rust, Neovim for C and VSCodium for Ansible + web development.

I use vis to write code, ^Z and make/mk to build the project. Most of the debugging is done with valgrind and eventually gdb though my use is very limited.

When I work on manpages, I use wendy to automatically preview manpages everytime the source file changes.

I do game dev, and I've been loving VSCode. I used to use a mishmash of stuff, but VSCode can do kinda everything. Working on retro-dev C/asm for NES or Genesis? Lua projects? Shaders? Debugging a native Linux/SDL game? Doing some math in a Julia notebook? Unity3D development? Working on Windows/Mac? The answer is VSCode to all! I still use vim for some light stuff or working on remote machines, but meh... VSCode has nice defaults for me without having to fiddle.

For my native Linux gamedev, I've just been using the MS Cmake and Cpp-tools extensions. They work great, and you can script up the rest with actions. The debugger isn't great, but it's convenient and good enough for simple crashes. I switch to GDB when things get interesting though. I suppose I have an extension for shaders too, but it's just syntax highlighting.

CLion for Rust/C++, VS Code for web dev stuff

Hi! web dev here. It's time to change your setup ever so slightly with VSCodium, and electerm too optionally: https://vscodium.com/ https://github.com/electerm/electerm

I usually install all my setups in PopOS or a server I'm developing on: https://github.com/gnubyte/debian-setup/blob/master/setup.sh

Then install Insomnia.rest, VSCodium, and finally electerm.

Basically I'll program in nodeJS, BunJS, or python.

Then I'll ask chatGPT via Rubberduck (link below) to generate a docker and docker compose live mount for my dependencies of my frontend and backends. Then I begin to iterate over my work.

https://github.com/rubberduck-ai/rubberduck-vscode

My latest flow is basically to start with chatGPT, write a four paragraph description of what I want, have it save me about five hours of boiler plate nonsense, and then disconnect from chatGPT to do the advance stuff like handle security, data structure relationships, etc. Sometimes I go back to chatGPT for how an algorithm should be implemented for efficiency inside a short snippet, then apply it again to my code. There was some great bloom filter work it was able to help me with.

Other stuff I've been trying is like podman and I'm interested lately in Jenkins to do builds since I realized I have too many projects that build and work a particular way, I can't Shepard them all by hand. With that will likely come unit testing, both hopefully assisted by AI to cut down on time. I'd like to reinvest that time on hankerrank and frontend masters to start transitioning to something like rust.

I code in C/C++. Work laptop is windows, but the products run on various Linux and Unix flavors, as well as in Windows. So I use Clion on win, that syncs the code changes to a Linux VM for building and testing. The toolchain is in a docker image, so I can change the build and test environments without affecting each other. Since I need to test on different OSs, I have multiple VMs in a server at the office.

I use GVim for coding and text editing in general.

Programming wise, CLI tools (grep, sed, awk, sort, head, etc) are enough for most of my tasks. I've written a few Python TUI projects (uses Textual framework) but these are around 300-400 lines, so Vim is more than enough for my purposes. Don't even need any plugins.

Xfce spin Fedora using VS Code with CSharp dotnet omnisharp, sometime vim with coc nvim and omnisharp vim.

PHP intelephense, podman, kvm/qemu, some el clone or rhel cloud image, and windows server 2019 vhd to qcow2.

Other than that, firefox for frontend web debug.. For desktop dev, avalonia UI. Other than that, none.

Using VSCode with NeoVim plugin (allows Vim commands in VSC). Code JavaScript locally, deploy using GitHub and Docker/k8s.

I'm currently running Fedora Kinoite, via the Universal Blue kinoite-nvidia image.

A lot of the stuff I personally develop is done in Java/Kotlin, so for those projects I use IntelliJ (via the JetBrains "All Products Pack") to work. For everything else such as Rust which I've been slowly trying to get into, or PHP which I sometimes write for work I tend to use Neovim because its simple enough. I suspect as I start to build bigger projects in Rust I'll start using it through IntelliJ or CLion to have access to a nice debugging environment, but so far the little bit of debugging that I've needed can be done through rust-gdb.

Its a nice simple workflow, and Fedora already has podman installed for when I'm utilizing Docker as well which is nice.

I do DevSecOps/SysAdmin type stuff mostly so vscode with devcontainers being pushed into gitlab-ci for checks and deployments (Ansible, terraform, k8s manifests, helm charts, docker files and occasionally back to my roots with sh and python scripts as needed).

Sometimes though I just toolbox my devcontainers and work client out of there and vim, when I'm just trying stuff out.

Yakuake with oh my zsh some plugins and themes and vscode (trying to switch to lapce) in Rust with cargo on Fedora

Bspwm/sxhkd on Artix Linux with runit init.

Neovim, lots of plugins and custom shortcuts and commands. Espanso text expander for even more functionality.

St terminal with zsh. Lots of aliases and shell scripts add lots more functionality.

JavaScript Developer with some docker integration.