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

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

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

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.

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.

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?

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).

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.

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)

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.

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.

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

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.

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/<branch> and all info related to a task in ~/dev//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.

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]

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.

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.

• 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

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.

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.

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