1. 17

Share your favorite dev tools that helps you remain productive such as text editors,terminal,configs and etc

  1.  

  2. 10

    My development environment is kinda like the UNIX philosophy version of an IDE. I use:

    • Fish as my shell
    • Kakoune as my text editor
    • tmux for windowing and persistent session stuff
    • fzf for fuzzily changing directories and picking files
    • ripgrep and fd for searching
    • kitty as my terminal emulator

    I’m probably forgetting other things, but those are the important ones. My personal laptop runs macOS, but all other machines run NixOS.

    I work almost entirely with Haskell and Nix, so language specific tools include stuff like Cabal, ghcid, ormolu, and HLint. I also use home-manager for declarative package management, as opposed to the more imperative nix-env style.

    1. 2

      As @damantisshrimp said, I also have almost the same configuration:

      • s/fish/bash/
      • s/Kakoune/Neovim/
      • s/kitty/uxterm/

      Some other things that I think it is worth to mention:

      • i3 as window manager;
      • Zeal for offline documentation;
      • w3m for quick internet surfing (mostly StackOverflow and online documentation);
      • it might sound crazy, but the amount of time I use find (application of operations on set of files), awk (querying) , sed (simple modifications), and ed (more complex modifications) daily makes them deserve a special entry in this list.
      1. 2

        I have almost the same environment, except I couldn’t completely switch to Kakoune so I went back to the comfort of Neovim.

        Great setup ;)

      2. 7

        Recently I have been migrating to programming with my voice using https://talonvoice.com

        This is having a cascading effect on the rest of my technology stack as I rearrange things to optimize for what can be controlled most easily with my voice.

        For example, I have always been a vim user, but now I am finding that I prefer VSCode with the vim plugin. file navigation and a few other things that I do frequently are easier. Being able to hover over identifiers for type information saves me from a lot of trips to documentation or the terminal. it’s also easier for me to develop missing functionality that I would like to exist in typescript than vimscript.

        I’m probably going to be switching back to fish, so that I can take advantage of its auto complete.

        1. 1

          Once you’ve been doing it for a month, could you do a small video or write up? I think this is something we’ve seen attempted many times over the years but nothing seems substantial.

          1. 2

            I fully plan to! In the meantime you can watch the talk that inspired me: https://www.deconstructconf.com/2019/emily-shea-voice-driven-development

        2. 6

          vanilla vim in a basic terminal. Works everywhere, and I don’t have to spend brain-cycles thinking about it.

          1. 2

            How do you deal with multi language barrier? ie. Space vs Tabs in different project? Do you manually expandtab/tabstop?

            1. 2

              Personally, until I need to do it often enough to put in my .vimrc for a particular filetype, I kinda already remember the :setl sw=2 ts=2 et (replace 2 with whatever needed) “magic incantation” for when needed. Umm… a moment of self-reflection: is vim really a stockholm-syndrome lover I thought it to be in my younger days?… Yet in other editors, I’d have to do it by mouse or keyboard shortcuts anyway…

              1. 1

                I have an EditorConfig plugin, many projects ship with an .editorconfig file these days.

                I also have some autocmd for specific languages/projects; you can just match it by directory:

                au FileType go nnoremap MM :silent! :wa<CR>:compiler go<CR>:silent make!<CR>:redraw!<CR>
                au FileType go nnoremap TT :silent! :wa<CR>:compiler gotest<CR>:silent make!<CR>:redraw!<CR>
                
                autocmd BufReadPre /home/martin/code/goatcounter/*.go
                            \  if $CGO_ENABLED is# '' | let $CGO_ENABLED = 0 | endif
                            \| let g:gopher_install_package = 'zgo.at/goatcounter/cmd/goatcounter'
                

                You can set tabs/spaces/etc. there too, if required.

                1. 2

                  I think “vanilla vim” was important context for the question. With custom config, these things become easy, as you point out.

                  1. 1

                    Ah right; I assumed “vanilla” meant “without plugins”, but yeah, could be “without config” too 😅

            2. 4
              • IDEA Ultimate (aka IntelliJ IDEA). I last wrote Java (and it wasn’t much then) checks notes 5 years ago, and I still don’t get why each of the language-specific JetBrains editors exists, but apparently this is the only one that will support plugins for any other random language (e.g. PHPStorm can’t install the python language plugin, and PyCharm can’t install the PHP language plugin).

              • Vagrant. From a shared single-VM dev environment, to an 8-10 VM simulation of a ‘production’ site. Yes it has a few rough edges, but realistically everything does, and I’m mostly familiar with these rough edges now.

              • A pretty vanilla zsh on macOS, the only really ‘custom’ thing is a little script to setup & store dotfiles & similar in iCloud drive.

              • TablePlus (for SQL)

              • Kaleidoscope because command line diffs are insane for anything beyond about 2 files.

              1. 1

                About the different JetBrains products, my guess is that you only pay for the features you really use. It’s still weird that you have to install different applications if you want to mix and match e.g. Python and PHP, but not Java.

                I don’t think I ever got the hang of a GUI for doing SQL. I’ve used DB Visualizer a bit, but too many times there are situations where the command line is just a few keystrokes away.

                1. 3

                  I get the pricing difference - but why not just have the different licences enable different plugins then - and they even acknowledge this weird behaviour with both a “all products” licence and a dedicated desktop tool, just to install/update/launch all the various tools.

                  Re: SQL - the GUI part is 99% about viewing results more easily - the vast majority of the time it’s just showing me the result of a query I wrote (or occasionally copied from an error log).

              2. 4

                I’m very surprised that nobody has said they use VS Code yet. I figured it had the lion’s share of the market, but maybe that’s just webdevs.

                I use VS Code exclusively as my text editor, except for Vim which I occasionally use for editing config files and writing commit messages. I write Rust for my dayjob (fullstack) and most side projects (also fullstack), and I use the trunk rust-analyzer which works pretty well these days except for situations with lots of complex macros and codegen. I also write a good deal of JavaScript/TypeScript which VS Code supports 100% out of the box.

                I make very extensive use of full-codebase search with VS Code (ctrl + shift + f) as well as normal find. I also make extreme use of go-to definition; I feel that my workflow is neutered if I’m working anywhere without both of those features available, regardless of language. I find that I only use the file tree on the left secondarily; I primarily navigate between files by following go-to definition or clicking on results in all-code search.

                I use code formatters for every language I write in; I can barely work without one now. I type out a whole piece of logic without pressing newline or space unless necessary and then have it auto-format when I save. I use linter plugins for VS Code wherever available. The thought of not having at least syntax checking in-editor feels incredibly constraining.

                A few other editor plugins:

                • Auto add trailing newline
                • Auto trim trailing whitespace
                • Side-by-side markdown preview
                • GitLens (show file history, show line history, show blame for currently hovered line in bottom bar, etc.)
                • Language-specific extensions wherever available
                • VS Code live share which I’ve used for pair programming a few times with mixed results

                I have my frontend, backend, and any other pieces running in their own tabs within my terminal (iTerm on Mac, Konsole on Linux desktop). I use zsh/OhMyZSH with some nice plugins:

                • autojump (fuzzy-jump to directory by partial/close name)
                • show shadow completing all commands while typing (incredibly helpful)
                • show git branch and dirty status for current directory if in a git repo

                I have a pretty basic set of dotfiles with mostly just config for stuff like NVM, PATH, GOPATH, etc. I have some useful aliases which I use (gd for git diff, cb for cargo build, etc.)

                I have three monitors and generally have terminal and/or web browser on the left one, text editor on the middle one, and web browser on the right (usually for displaying the webapp I’m working on). I keep all my windows maximized at all times and primarily use the taskbar to switch between different windows on the same screen. Taskbar is set to only show tabs for windows on the current screen.

                I rarely use a debugger with the exception of the browser devtools debugger when I use heavily. I rarely use repls with the exception of, again, browser devtools which I use extremely heavily. When I do use a debugger, I use VS Code’s integrated debugging for Rust and C# (those are the only two languages I’ve used a proper debugger before so far).

                Rust utils have taken over my system, replacing many traditional Linux ones:

                • ripgrep (grep replacement)
                • fd (find replacement)
                • dutree (visual size distribution of subdirs/files)
                • twiggy (Wasm size profiler)
                1. 2

                  I’ve started using vscode for my typescript and kept using sublime for everything else.

                  Extremely similar overall, most problems have been just learning new shortcuts etc.

                  However:

                  • Sublime is 1 frame faster at rendering text after I press a key. Bothers me slightly in vscode, but most don’t appear to notice.
                  • Several times a week, code gets into a weird state where code search gets stuck and takes 3-5 seconds to respond to input. Appears to be pegging a CPU. I suspect there’s a keyboard shortcut I’m accidentally triggering which tells it to search everything, even .git and node_modules but haven’t figured out what it is.
                  1. 1

                    Vscode gets pretty slowly when dealing with large projects. Have you experienced that. Even though the eco system is great and they wide range of plugins

                  2. 3

                    I’ll try to give a sketch of an Emacs-centered workflow. My main tools are (surprisingly) GNU Emacs and xterm+bash. I don’t need much more than that.

                    When working on something, I usually have one of two setups:

                    • For compiled languages, I split Emacs intro three windows (for non-Emacs users, what the window manager calls a “window” is a “frame” in Emacs-speak, while a frame in the Emacs window is a “window”). Usually a file buffer on one side of the screen, and a vertically split window with a compile buffer on the top and a terminal*/dired below. These can be rotated easily (using window-swap-states). But I would usually order than so that rotating through the buffers makes sense. Binding recompile to a handy key is very useful, in my case I use the F2 key.
                    • For interpreted languages, assuming there is proper Emacs support, I would have mostly the same setup, except that the compile buffer would be replaced by a REPL, and I would tend to not have a terminal open.

                    Regarding Emacs extensions, projectile is very useful, but I’m not an advanced user. My main commands are projectile-find-file and projectile-kill-buffer. Sometimes I forget to use the latter, and then I end up with 700 opened buffers, like a few weeks ago. Other noteworthy packages are avy, for jumping to symbols, but also copying and moving them around, ivy/swiper, for faster completion and perhaps dumb-jump for looking up definitions without having to set anything up. Any other tips would be language specific.

                    This is my configuration, in case anyone cares, but I’m in the process of re-writing and shrinking it, so it’s not as tidy as it used to be.

                    * In my case Eshell.

                    1. 1

                      Out of curiosity: do you use xterm so you can use Alt + B and Alt + F to navigate readline?

                      At least in my case, that’s mostly the reason I use it over the other existing options.

                      1. 2

                        No, there’s no real reason. Sometimes I get bored and switch back to MATE’s terminal (or when i need to resize my terminal for an audience to recognize anything). But I just tried Alt-B and Alt-F in mate-terminal, and it worked, so I’m not sure what you’re talking about. Have you disabled the menu bar?

                        1. 1

                          But I just tried Alt-B and Alt-F in mate-terminal, and it worked, so I’m not sure what you’re talking about. Have you disabled the menu bar?

                          I am a bit embarrassed now, because I just tested it on gnome-terminal (on i3) and it has worked as well.

                          I had this memory I changed to xterm for that reason, though. Perhaps my memories is playing tricks on me.

                          Any how, I learned it works on gnome-terminal as well—and possibly everywhere else. :)

                          1. 1

                            The behaviour is totally unintuitive, and I remember just ignoring it for ages, so there’s nothing to be ashamed of :)

                      2. 1

                        It’s interesting how different our setups are considering we both use Emacs; it fascinates me every time I come across one how varied the users of Emacs are.

                        Thank you for your configuration, by the way. I can’t remember how I first came across it, but I’ve found a few nice settings in there, and like your list of inspirational configurations which I’ve also found a few nice things in. When you switched to Rmail I got quite excited, I barely know anyone else who uses it!

                        1. 2

                          Considering how “low-level” Emacs primitives are (buffer, window, frame, …) it doesn’t even surprise me. Most people in this thread use a window manager, and look at all the variation there!

                          Thank you for your configuration, by the way

                          It means a lot that people find what I do helpful! A lot of knowledge, methods and tricks about Emacs is lost in old configuration files or blog posts, so trying to dig this up for others is kind of interesting, especially because workflows have changed so much over time.

                          1. 1

                            Considering how “low-level” Emacs primitives are… Most people in this thread use a window manager

                            Considering I spend a lot of time proclaiming that Emacs is nothing more than an interface, I’m surprised I never made this comparison myself!

                            Yeah, maybe it’s quite sad but I do like to print off people’s init files and just read through them. There’s a lot of good stuff in a lot of them.

                      3. 3

                        I use Emacs, but in a way more reminiscent of Acme. Normally I have two windows next to each other: the current file and a shell buffer (not eshell or term, a comint shell buffer running rc), and I shell out to external commands a lot.

                        Notable parts of the configuration are the complete lack of syntax highlighting, the lack of any completion frameworks or fuzzy filterers (besides hippie), the lack of any advanced emacs features being used (I don’t use slime, geiser, or whatever for any language). I have a large amount of aliases and environment variables set to make sure that my home directory is not dirty (and have alias ls=ls -l) so that I don’t get lazy. I use 8-wide tabs instead of spaces (except for lisp) and ag instead of grep. Also, I use a light theme.

                        Most of the tools are use are written in C because I found it too time consuming to get a rust compiler compiled, and I’m at a stage in life where I’ve got the time to make hipster idealistic decisions like that.

                        Really there’s nothing interesting going on, which makes all my friends who care about this stuff think my setup’s odd because it’s so plain in comparison to whatever they have set up. I’ve been writing up a sort of live document explanation thing of what I use for my own reference over time here if anyone’s more interested.

                        1. 1

                          I really envy that you don’t use completion frameworks, I sometimes feel limited by how used I am to them. But I find your Acme-inspired approach interesting. Have you tried re-creating the keybindings? I was recently thinking that such a thing should be possible, but have never tried it.

                          Edit: Also, why rc?

                          1. 2

                            I really envy that you don’t use completion frameworks

                            I could never get on with how things would keep popping up in my buffer, and in Emacs in particular it didn’t feel like it had been built to support these interactions - I had a few issues with them conflicting with other things I’d set up and ultimately I didn’t think I got any more out of it than hippie-expand.

                            Have you tried re-creating the keybindings?

                            Which keybindings are you referring to? Aren’t most of them pretty similar to Emacs? I have C-u set to delete to the start of the line instead of run prefix argument, but that was more of a general unix coherence step than to be like Acme. There’s the escape key functionality, but I never liked that much.

                            My general idea with the Acme influence is to use external shell scripts, using Emacs as a way to interface with text output and formatted by other tools. It’s still very much a work in progress, trying to get things like executing a region, or the current line or whatever, to work well. I probably haven’t explained this the best, but I hope it at least gives an idea.

                            why rc?

                            hipster points ;)

                            More seriously, I’d been trying out quite a few of the plan 9 tools, and appreciated how simple they were fundamentally - quite a lot like suckless, although generally the simplicity is more thought out than a lot of the suckless projects. I tried writing a few shell scripts in it and it wasn’t bad, so I thought I’d stick with it, for the moment at least. There are a few things I don’t like about it, like it doesn’t read .profile, and ~ never works for me, but for my purposes in Emacs it works well. I use mksh as my login shell.

                            1. 1

                              I could never get on with how things would keep popping up in my buffer, and in Emacs in particular it didn’t feel like it had been built to support these interactions

                              There are limits, I think helm and company for example transgress them, but in my opinion, Ivy has done a good job at keeping an Emacs-y essence to their UI. I’m particularly fond of their CAPF frontend, that just inserts a few lines between the current and next line with completions to choose from.

                              Which keybindings are you referring to?

                              Oops, I meant mouse-chrords. The way they have done cutting, snarfing, searching and so on.

                              My general idea with the Acme influence is to use external shell scripts, using Emacs as a way to interface with text output and formatted by other tools

                              That reminds me of a @LeahNeukirchen wrote a function called “bang”, that merges shell-command with Sam’s interface (afaik that Acme inherits via Edit?). I converted it into a package, in case that interests you.

                              1. 1

                                I’m particularly fond of their CAPF frontend

                                That doesn’t look bad. I think that I will continue not to use one though, but it’s nice that better systems are becoming available.

                                mouse-chrords

                                I find the mouse chords very elegant, and I’m sure they could be implemented in Emacs, but they are also actually the reason I am using Emacs rather than Acme; my mouse is not very good, and I didn’t like having to carry it along with my laptop anyway. I also like being able to work just in a tty, which is why I’m trying to replicate my preferred bits of the functionality in emacs.

                                @LeahNeukirchen wrote a function called “bang”

                                I do indeed have it in my init.el :) her configuration is a very good read. I might not use the package, since it’s only small and currently I don’t use package.el at all. Cool that you did that though.

                                1. 1

                                  I also define ffap-at-mouse-and-point-or-menu, which is Acme-style file visiting/link following in Emacs.

                        2. 2

                          Most of my work is golang, so I spend most of my time in jetbrains GoLand. It’s pretty great, well worth the license.

                          1. 2

                            For some years now, my setup has remained basically the same.

                            An iTerm2 terminal , in full-screen, on a global hotkey, which appears instantly with no animation. Inside that, a tmux session for each project I am working on (I have three commercial projects).

                            Inside the tmux session for a given project, I have various windows which run e.g. psql, redis-{server,cli}, and I work from a window which contains an equal vertical split (as in the divider runs vertically).

                            On the left side is my Haskell or Elm compiler. With Haskell, I’m always working in GHCi. I use it for interactive development, inspecting types, running my project’s tests, and running my project’s local development server. My GHCi is configured with a number of flags which enable fast, incremental compilation, so I have a fast feedback loop even on Haskell projects of a couple hundred modules and 25K+ LOC. For Elm it’s similar, though I rarely use Elm’s repl and it’s separate from the local development server runner anyway.

                            On my right side is vim. I use vim-dispatch to send commands from vim to the GHCi in the other pane.

                            Everything except for vim comes from a nix-shell.

                            1. 2

                              My one is described in GitHub repo for macOS & iOS. I got new mac a month ago so it is further simplified, will update the repos shortly.

                              But of the recent things, I moved most project management to Notion from Trello. Started using VS Code insiders with minimal extensions.

                              I want to rewrite and/or start using https://github.com/Keats/kickstart to bootstrap new projects.

                              1. 2

                                Thanks for sharing your setup and your workflow with us. Your Git repositories, and Gitbook are a goldmine of fascinating information/tips.

                              2. 1

                                In terms of editor, it depends on what I’m doing

                                • Emacs (using doom-emacs with some of my own tweaks) for most usage
                                • VSCode when I just need completion for a language to work perfectly - I’d love to phase this out once my emacs setup gets a little better
                                • vim when I’m on a server - it’s just ubiquitous

                                Other tools:

                                • zsh with zsh-utils to keep a fairly minimal setup.
                                • tmux
                                • ripgrep for searching
                                • iTerm2, though I’ve been playing with alacritty

                                Essential tools between editors:

                                • editorconfig - pretty much every editor has a plugin for this - it’s nice to set indentation up once and forget about it
                                • git - in emacs, this is through magit, otherwise just through the command line. After working at Bitbucket for a few years, you tend to get used to the oddities in the command line interface.

                                I really like emacs and wish I could just use that for everything, but I’ve had some issues with plugin stability, especially around lsp/completion support.

                                If anyone’s interested, I maintain a number of themes for emacs:

                                I also maintain zsh-utils, and use that in place of prezto (which I also work on a bit).

                                1. 1

                                  VSCode when I just need completion for a language to work perfectly - I’d love to phase this out once my emacs setup gets a little better

                                  What environments are you struggling with? Or are you talking about completion frameworks?

                                  1. 2

                                    In particular, I’ve had some issues with rust (either rls or the connection keeps crashing - I haven’t had the time to debug it yet) and JS/TS just isn’t on par with VSCode. I haven’t tried python recently, but at least in my personal config I’ve had it stable-ish for a while, so I’m not as worried about that one.

                                  2. 1

                                    Does vscode gets slower. I think vscode is basically like modern day emacs

                                    1. 1

                                      I think vscode is basically like modern day emacs?

                                      Why? They seems like two projects with different goals to me.

                                  3. 1
                                    • Fish shell
                                    • Kitty terminal emulator
                                    • NeoVim + some plugins
                                    • Nix on macOS
                                    • Dash
                                    • ElixirLS + ErlangLS
                                    • RipGrep as search tool

                                    Mostly that is it.

                                    1. 1

                                      Hows your experience with NixOs

                                      1. 1

                                        I do not have much experience with NixOS I just use Nix (without OS part).

                                    2. 1

                                      I mostly do PHP development for work where I use PHPStorm (makes debugging easier) but besides that my setup goes like this:

                                      • Alacritty as terminal emulator
                                      • Zsh with antigen, using only some of the oh-my-zsh features.
                                      • tmux, I only use 1 session and manage everything there.
                                      • neovim with a few plugins I don’t consider minimal but gets me through my needs as I’m usually moving between languages (Rust and Python mainly, but from time to time I have to do some JS/HTML)
                                      • fzf, exa, ripgrep for search and navigating directories.

                                      So regardless of the DE/WM I use at least 3 workspaces in fullscreen for Browser, Alacritty & PHPStorm on a regular day at work.

                                      Also I’m one of those with vim-style keybindings everywhere (except shell) so Firefox, wm (2bwm) and PHPStorm have their Vim mode. Only use mouse for browser.

                                      1. 1

                                        For me, my Dev workflow centers around Vim modes

                                        At work, that’s gvim+VimWikis for note taking, VsVim for writing C#, LinqPad+Vi mode for prototyping code and exploring data. Outside of that, I have notepad++, a menagerie of CLI tools for various conveniences to make the Windows command line less painful. They include directory bookmarks, my own version of ls for windows, a cli punch clock, and a small RPN evaluator for the odd job. I also have a tiny webapp for formatting commit messages and keeping an eye on builds. These tools form a little nest of situated software that makes my day a lot less painful.

                                        For personal stuff, it’s mostly Vim+bash+tmux+Nim (used to be Go), and JS where appropriate. When I get a better laptop for it, I’ll probably get back into Godot.

                                        1. 1

                                          My philosophy is not to make too many custom bindings or shortcuts, in case i have to work on a different machine. I’m also too stubborn to use vim.

                                          • gnome+gTile and lxterminal
                                          • micro for shorter edits (looking for a replacement here)
                                          • Atom for longer sessions. Configured with lots of QoL addons and bindings.
                                          • bash+fzf, but been wanting to switch to zsh
                                          • git+make+entr
                                          • graphviz <3
                                          • psql, sqlite3 or mysql in shell if needed
                                          • jinja2/nunjucks/twig/tera is my go-to templating framework

                                          tableplus and kakoune which i’ve seen in this thread seems great, and i will look into it If anyone know of a simple terminal editor with not-vim not-emax bindings, but with normal windows-esque bindings then i’m all ears

                                          1. 1

                                            I’ve been writing a lot of Rust lately, and I spent some time configuring rust-analyzer to work through vim-lsp, etc. If I recall correctly I started with the instructions for rls. Anyway, it’s been good to be able to use the type information in the language without needing to use a full IDE – I recommend it! As an aside, to get proper floating boxes to render I think you need at least VIM 8.2, which was still apparently unavailable last week when I checked last.

                                            1. 1

                                              As an aside, to get proper floating boxes to render I think you need at least VIM 8.2, which was still apparently unavailable last week when I checked last.

                                              popup windows were added throughout the 8.1 release with many different patches (some incompatible), it’s just easiest to say “8.2”, but the first patch was in 8.1.1364, but you probably want at least 8.1.1513. Some features and enhancements were added in later versions.

                                              Vim versions are rather idiosyncratic: every commit to master is a new “patchlevel”, and every once in a while a new “version” is released, which is again, just a commit to master with some docs updates, but outside of that is quite arbitrary.

                                              Also pretty easy to build Vim yourself if you want a newer version than what your distro has.

                                              1. 1

                                                Neovim does a far better job of versioning appropriately and clearly, which is nice. It’s possible that any given distro version might have a too-old Vim but a new enough Neovim (although compiling yourself or using a rolling-release distribution isn’t too hard).

                                                1. 1

                                                  Yeah, NeoVim is a bit more standard in how it does things. NeoVim has popup windows, but I think the API is incompatible with Vim’s.

                                            2. 1

                                              I do some coding at work but most of my time is spent doing other things.

                                              Work (Windows 10)

                                              • Visual Studio 2019 - mostly C#, some C++
                                              • Notepad++ - PowerShell
                                              • Cygwin - the usual Unix commands, anything I distribute is in PowerShell.
                                                I intend to try WSL at some point.
                                              • Sourcetree
                                              • SQL Management Studio

                                              Home (macOS)

                                              • Xcode - C, C++
                                              • Sourcetree
                                              • IntelliJ - Java, Kotlin, Scala
                                              • dozens of terminal windows
                                              1. 1

                                                Nice

                                              2. 1

                                                A recent breakthrough improvement for my workplace workflow was actually in physical world, and on recommendation from a lobste.rs user: discovering and starting to use a discbound notebook. It allows me to easily organise and rearrange my working notes, whereas before my notebook was chaotically intermixed and finding stuff in it was nearly impossible.

                                                Other than that I found similar help in Tree Style Tabs plugin for Firefox, though it also has some aspects I don’t love; but without it I’d be in a worse situation at work. I live by Gesturefy & NoScript in Firefox as well.

                                                Other than that, basically vim + Go + Linux/Mac at work, vim + Nim/Go + Windows/Linux at home; nothing else that is special comes to my mind. I mean, there’s a lot of small things in configs, such as .inputrc tweaks to make bash tab-completion much better, or a ~/bin/gl script containing more or less git log --graph --oneline --decorate --all, etc. They all come together for overall boost, but too much to describe here. I store most of my config via Nix’s home-manager on Linux, though it has pros & cons & doesn’t support Windows.

                                                1. 2

                                                  PS. Can’t edit my post anymore, but I wanted to let myself also mention Ultimate Plumber, which is a tool I myself actually created, out of a burning need (so I think it fits the OP question), and other people seem to really like it too…

                                                2. 1

                                                  My dev env:

                                                  • iTerm2 on macOS, Konsole on Linux, WSL/Windows Terminal on Home PC
                                                  • zsh with prezto everywhere
                                                  • mosh when I’m not working from office
                                                  • tmux for persistent sessions on servers
                                                  • VSCode / Neovim for editing (VSCode Remote extensions are very good)
                                                  • ripgrep
                                                  • git
                                                  • docker

                                                  Configs:

                                                  • Victor Mono or Cascadia Code font
                                                  • Pure prompt
                                                  • Solarized theme on terminal. I keep switching in text editors
                                                  • EditorConfig

                                                  Language specific tools:

                                                  • Prettier
                                                  • Black
                                                  1. 1

                                                    1. zsh
                                                    2. neovim
                                                    3. iterm2
                                                    4. JetBrains DataGrip

                                                    I used IntelliJ for a few years, but found it just got bogged right down when you start into large-scale multi-language projects. There was a significant typing delay for a while where you would hammer on the keys and then could watch the editor trying to catch up that just finally did my head in and made me quit it and move back to vim/nvim. I still pop it open from time to time for the debugging UI, but other than that i’m 99.9% of the time in vim.

                                                    I tried Kakoune for a bit as well, but just never really committed to it. I write code across rust, python, golang, C++, JavaScript, HTML/CSS and a lot of infra and config stuff.

                                                    1. 1
                                                      • Fork (previously GitX) is a productivity boost for me. Using git fearlessly requires knowing “where” you are in the graph of commits at all times.

                                                      • Sublime with Rust extension reports errors inline, and has a button to apply compiler’s fix suggestion. It’s a small thing, and probably Java-IDE devs had it since ‘90s, but it’s new for me and I love it.

                                                      • Firefox with Tree Style Tabs and Containers extensions. I need a million tabs open.

                                                      • Flycut clipboard manager. It has saved me countless times when I’ve cut some bit of code and forgot about it. Or needed to paste again some bug number or a URL from 15 minutes ago.

                                                      1. 1

                                                        My environment is a mess but slowly it’s converging on what I want it to be. I use:

                                                        • NixOS + XMonad, the goal is to make xmonad central to everything and reduce the dependence on text editor, web browser and terminal window management features.
                                                        • Kitty as terminal, I still use the kitty tabs but I will move to xmonad tabs (and probably a more minimal terminal) once I have finished building a couple of other features in my xmonad.
                                                        • Spacemacs as IDE, neovim as a terminal editor, I know it’s a bit weird but it’s expedient for now. I’m slowly weaning myself off of spacemacs window management, now I mostly have emacsclients and terminals tiling my screens rather than a big emacs window with splits.
                                                        • Qutebrowser and firefox for browsing, this is similar to above, qutebrowser is great and it’s easy to make small named sessions to open and close. However I have a massive firefox session that I need to slowly break apart and organize.
                                                        • Zathura for pdfs, I read a lot of pdfs so this is relevant I suppose, it’s also another good thing about using qutebrowser is that its UI fits my pdf flow better. I use pboy or paperboy (haskell TUI) to rename and organize my pdfs.

                                                        I use find and ripgrep a lot but I rarely reach for tmux or fzf, although fzf is a very useful tool so I should probably start forcing myself to use it until I start reaching for it.

                                                        Edit for “workflow”

                                                        At work I do go, I have emacs set up with a language server and a tags file so I can jump to definition or hover on a symbol for information and such things. When I work I mostly just make a couple of changes, run the local tests, run the global linter and then if it passes I send it to the CI, sometimes there’s a problem in some other test, then I fix those and run the local tests and global linter but never the global test suite because it locks me out of my system pretty much…. I have a portrait screen on each side of my laptop so it’s like having 5-7 laptop screens, the layout I most often end up with is some kind of “emacs region”, “browser region” and “terminal region” but I change this as I go. My workspaces use a binary space partition layout and I have hotkeys to rearrange the trees.

                                                        When I do things in my free time it’s mostly going to be related to my environment, so nix and haskell, I don’t have a good flow for nix and it’s kind of frustrating but I am actually making myself a tool to fix this (and other similar problems). For haskell I use ghci a lot but when I’m at home I only have the laptop screen, so normally I have an emacs window and a terminal window and then use the kitty tabs and emacs window splits. It doesn’t scale well because I keep shuffling through and it’s hard to reference things quickly or keep two things side by side or something. My work window management flow is better but it just means that my WM config is sufficient when I have enough screen space but I am missing quite a few features for managing many windows in a smaller viewport.

                                                        Currently where I suffer the most is with note-taking, I use org-mode but I’d rather have a graph database.

                                                        1. 1

                                                          Depends on the machine I’m working on, but common elements are:

                                                          • Zsh, tmux
                                                          • Vim for Python, YAML, XML, Make, etc…
                                                          • IntelliJ for Java
                                                          • VS Code for HTML, CSS, JavaScript and TypeScript
                                                          • Firefox with adblocker and privacy extensions
                                                          • All the nice Rust utilities that popped in the last few years: bat, fd, hexyl, rg, etc…

                                                          I do customize all the tools I use. For now I settled on:

                                                          • Fira Code with ligatures
                                                          • Ayu Theme
                                                          • Horrible hacks to make those damned italics work with tmux and vim

                                                          Desktop is on Manjaro, work machine is on MacOS.

                                                          1. 1

                                                            I’m a web developer, so there’s a few tools I use every single day.

                                                            • PHPStorm - my IDE that I use for PHP and Node.js development - very good debugging and code completion included here.
                                                            • ElementaryOS - very beautiful, but I’m moving back to Xubuntu at the end of the month.
                                                            • Vagrant - spins up a PHP environment for Magento 2 development - as well as other PHP services and apps we develop in house. It also has Node.js installed for front end building
                                                            • Node.js - right on the bare metal to run scripts, test stuff
                                                            • PHP on the bare metal to test, write, etc
                                                            • SAM for developing single AWS Lambdas locally
                                                            • Slack to talk to the team
                                                            • Firefox is the main browser, we have Office 365 so I use the Outlook web client a lot for emails - the first time I ever let a web app push notifications through the browser
                                                            • I use regular old BASH with TMUX in my terminal
                                                            • Vim for editing configs and other system files
                                                            • HTTPie for testing RESTful APIs and services
                                                            • DBeaver for Database Management

                                                            That’s all I can think of that I use every day.

                                                            1. 1

                                                              My development environment is what I would call traditional:

                                                              • MacOS with a set of must-have applications: Yabai, skhd, Alfred
                                                              • Things for GTD, Apple Notes, Tomighty for Pomodoro
                                                              • IntelliJ Ultimate: I love its flexibility as I work with many different languages and platforms, including Java, Kotlin, Typescript, Python, etc.
                                                              • iTerm2/Tmux/Zsh for my shell needs. I use a bunch of aliases (notably around git), and a few utilities to make my life easier, including: bat (pretty cat), fzf, htop, and tldr
                                                              • vim for text edition in shell sessions or on remote servers (ubiquitous)
                                                              • VSCode (from Sublime Text) for all my text editing needs
                                                              • Docker + Docker-Compose for my local development environment
                                                              1. 1
                                                                • Bash shell
                                                                • Kitty terminal emulator
                                                                • Tmux (when remoting in to my linux box and at work)
                                                                • Emacs (pretty vanilla these days, just a few extra packages)
                                                                • WindowChef for my X11 WM
                                                                • Make (except for Rails)… even for Go, muscle memory and shorter to type :)
                                                                • Basic POSIX tooling (grep, etc)
                                                                • Aging (but still going strong!) 1st gen Retina MacBook Pro (mid-2012)
                                                                • Newish desktop Linux box (2015) runnng Arch
                                                                1. 1

                                                                  I try to avoid customizing my setup too much as I find it makes me less effective on vanilla configurations. I run XFCE (@Home) on Devuan, ksh or bash for my shell, vim with plugins that avoid adding features and usually complement or improve core functionality, Firefox with no plugins besides privacybadger/https everywhere. I don’t have many shell aliases, and I avoid aliases that rename key functions in utilities (e.g. I don’t alias any git subcommands).

                                                                  @Work: I write C++ and Python primarily. sshed into a Linux box from a Windows machine (which is not fun – I wish I had a Linux or Mac desktop). Since installing things is a bear at my place, I mostly work with stock vim with minimal plugins, and whatever is installed on a vanilla RHEL server. We also have tmux thankfully.

                                                                  For vim I usually get vim-surround and a bunch of custom vim functions that I can copy/paste into my vimrc (like a function to toggle open a vim 8 terminal or a function to toggle open the quick fix list. See my .vimrc).

                                                                  I run everything in tmux so if my VPN drops or I suspend my laptop, I can log back onto the server and just tmux attach to pick up where I left off. My workflow usually consists of hacking away in vim, hitting <leader>m which builds the project, hitting Ctrl-Z to throw the vim session in the background, run some tests, hit fg to bring back vim and repeat. If I have compile errors, I run <leader>q which is bound to a function that toggles the quickfix window to allow me to quickly see compile time errors. I can :cnext or :cprev to jump to relevant lines.

                                                                  To find files, I use <leader>o bound to :find which recursively searches the directories in path. gb runs :ls<CR>:b<space> to get a list of open buffers. <leader>a finds the “alternate” file – in C/C++ it swaps between the header/source file by searching for the file with the same name in the vim path.

                                                                  @Home: I try to avoid diverging too much from my workflow at work so I don’t build muscle memory that I can’t rely on. Many of the keybindings are the same, but I’ll have some quality of life improvements, like fzf bindings for listing buffers or finding files, running ALE to get error messages while I work in code, vim-slueth to autodetect whitespace settings (tabstop, shiftwidth, etc), AsyncRun’s :make so <leader>m builds in the background, traces.vim for interactive search/replace. One thing I have configured for home that I don’t have setup for work is vimwiki with fzf searching that’s loosely based on Zettelkasten. The wiki’s markdown files are versioned with git.

                                                                  For python projects, I usually have <leader>m bound to run tests, and the quickfix window shows test results.