What is good DX for you?

I've been thinking a lot about good developer experience lately and I've been wondering what's the most important for you when it comes to DX?

Are there tools that stand out to you because of great DX?
What do you do to improve DX for the tools / services / projects you are working?

Many talks & articles mention for example things like:

• Ease of Use
• Consistency in the processes
• Clarity / Transparency
• (Experienced &) accessible community

All of which makes sense, but is also a bit abstract (what makes tools easy to use, right?).

Personally, I also find clear documentation super important to provide an easy way to approach new tools with little or no experience and lower the threshold.

Super curious about your thoughts ✨

Comments

[Brad]

I personally like tools that remove the most cognitive load off of me as possible. Stuff like auto-complete+intellisense+in-editor-documentation are all things that save my brain from needing to "think" about those things as they are just there.

So the best tools in that case aren't something you decide to use or not use, rather it's something that is just being used continually without you even knowing it, but you leverage it.

In that sense tools that are integrated into what your working on creates the best developer experience.

[squidbe]

100% this.

In an ideal software engineering world, engineers would only expend mental energy on figuring out how best to build features that delight users. All the other things that distract an engineer's mind just make it slower/harder to build what users actually want.

[Josefine Schfr]

Oh I love this idea, thank you for sharing. Cognitive load is such a big factor - any way in which it can be reduced, improves any experience 🙌

[Hassan Schroeder]

For using a language or an API I want documentation that tells me the input and output shapes of every function or method, ideally one or more usage examples, and a link to the source if I need to go deeper. Elixir's doc is a great example that hits all those points.

Well-integrated tooling for formatting, compilation, testing, deployment is a big plus (and Elixir is again a great example).

Tools like editors should be configurable and extensible (plugins, themes) while providing sane defaults.

[Raí B. Toffoletto]

Proper documentation and extensibility! Every framework has its trades off, but proper docs make all the difference in DX. NextJS and @MUI are my go to web frameworks due that. 🙂

[Raí B. Toffoletto]

Then a good linter and formatting helpers to integrate into your favorite IDE/editor.

[Josefine Schfr]

Absolutely, documentation is so important.

[Ingo Steinke]

Good developer experience: my tools work and help me do my actual work (like optimizing CSS for a frontend design) instead of standing in my way (like wasting 2 days work to configure webpack).

[Joe Mainwaring]

I have two tenets when it comes to designing a developer experience:

• Think less
• Do Less

I know those are abstract, but in terms of how those have translated into improvements I've made to the developer experience on my projects:

• Pull Request templates, so developers have a checklist and questions to answer as part of ensuring the feature branch passes the necessary quality controls.
• Developer Dependencies like husky, lint-staged, or prettier, which perform automated steps on code changes when they are committed.
• Slack alerts that tag users when their automations fail, enabling them to respond to the failure more quickly
• Add workflows like npm run create which generate boilerplate code for developers who are starting new feature branches
• Monorepo automations which keep root-level configurations up to date, like dependabot scanning.
• Chaining an CLI authentication command before the intended operational command via an npm script so the developer doesn't have to manually execute additional commands when they discover they're not authenticated.
• Replacing our homebrewed secrets management system (secrets committed to code using encryption) with 1Password's Secret Management solution. Developers no longer have to deal with encrypting the values (One of the developer's least favorite processes) and my infrastrucutre team doesn't have to deal with keeping duplicated values in sync.

[Sean Allin Newell]

GraphiQL scheme discovery comes to mind, it's all just intellisense in the end tho, but oh so useful. Also fuzzy file fingers (ag/rg ctrl-p, etc) all help me out daily/hourly.

When i have to build around it, like scripts or tooling to manage docker or compose, that's when the DX suffers.

[official_dulin]

Do not open too many GUI tools

[Julia 👩🏻‍💻 GDE]

Thanks for starting this discussion Josefine. I could gain a lot from your insights as well as from the great comments below.