I’ve noticed that my productivity is directly correlated with the size of the feedback loop. Even little things like inline errors or a particular keybinding that you use can mean a big difference, I feel! Please feel free to share anything—I’d love to hear about your environments!

  • zeizig@lemm.eeEnglish
    20·
    1 year ago

    A few things that come to mind (from small scale to larger scale optimizations):

    • Editor keybindings, editing code fast and conveniently (and having fun while doing it). Vim helps a lot here, but knowing the shortcuts in any editor (or other applications you use) is important.
    • Inline linting and compilation errors in the editor.
    • Static typing, your editor will already let you know if what you’re doing makes sense, and gives you suggestions on what you should do next.
    • Automatically running automated tests inside the editor, or just in a separate terminal tab.
    • Automatically recompiling code whenever it is changed. Something like Vite makes this very fast for web dev.
    • Hot module reloading avoids reloading the page after every change.
    • Automation in general avoids human errors and reduces the number of feedback loops. I quite like do-nothing scripting for this.
    • Using Docker avoids parts of the feedback loop for setting up a project entirely. Set up scripts improve it further.
    • Good documentation for setting up a project avoids the feedback loop of asking other devs for help.
    • A fast and convenient development environment makes things nicer in general.
    • If you use the conventional commits commit message format, then running the commit message linting right after writing your commit message.
    • Running code checks any time code is pushed. Even if you don’t run linting or check for compilation errors locally, your pipeline should still catch any errors as early as possible.
    • UI tests check if the main flows in your application are working, avoiding manual work of testing after deployments.
    • Continuous integration, merging code to the main branch as often as possible reduces conflicts and makes working in parallel with others easier. You get feedback about merge conflicts much faster.
    • Continuous deployment, you get quicker feedback from clients about your deployed code.
    • Error monitoring, know about runtime errors before clients report them.
    • Feature flags allow releasing features to some customers earlier, getting feedback earlier. This also enables decoupling releases from deployments.
    • Analytics helps to understand user behavior, allowing you to quicker make decisions about how to develop your product. This allows avoiding user interviews in some cases.
    • Sitting in the same room as your team (devs, designers, pms) shortens the feedback loop of asking them for input while working on your tasks. Remote work makes this more challenging, of course.
    • Having detailed designs in Figma shortens the feedback loop of asking designers for input. E.g., how many pixels should this padding be?
    • Code reviews allows you to get feedback on your code before it’s merged and causes problems in the future.
    • Design reviews (showing your implemented designs to your designer before merging) allows you to get feedback on your implementation earlier and avoids a new pull request with fixes.
    • Sitting down with your QA and testing your code together allows you to find mistakes in your code earlier than when QA tests your code in production after merging.
    • Releasing features often in small increments rather than a big release after many months of work (starting with the MVP and building on top of that) allows you to get feedback from clients often during the process. It’s also easier to pivot after a month of work rather than after 6 months. Splitting up features into smaller self-contained chunks is an art form on its own.

    This ended up being a pretty long list, but I hope it was useful!