Ask HN: What developer tools would you like to see?
My passion is writing developer tools. I like the feedback you get and the way it shapes the work.
It's cool when you can build software and someone runs it on their own data just a short while later and has a direct line of communication to you, providing a tight feedback loop.
I quit my job a few months ago and in a few months I'll have to find a new one. I thought I'd see if anybody had any ideas for tools they wanted to see written that lined up with my interests and that I could try my hand at, to see if I could make a go of working on dev tools for myself before going back into the job market.
229 comments
[ 3.7 ms ] story [ 254 ms ] threadSo, if you're willing to plunge head-first into cold water without proper documentation, have a look at: https://run.pickaroon.app
Keep in mind that I wrote this to scratch my own itch and will change it further as time allows. On the upside, I've been using it for my own dives through logs quite successfully already.
I also started a manual-ish readme that also isn´t public yet. It's written in markdown, so I'll have to look into how easy I can throw it onto my server or not. I might just make a separate GitHub repo for the time being.
Edit: I went with the GitHub route. You can find the current iteration of the readme here: https://pickaroon.github.io/readme/
This hits very close! Will have a look at this for sure, thanks.
- jq
- Google Sheets (after conversion to CSV)
- Beekeeper Studio (after conversion to SQLite)
This won't scale to large projects, but it works well for the logs from my little CLI tools I enjoy writing in my spare time.
I wrote about this (with some screenshots) at https://github.com/bbkane/logos#analyze-as-json
It's not specific to JSON/XML either, it works on any text that follows the usual conventions for structuring data in a textual way.
You can filter by level as well, but, usually I just press e/E to jump to the next/previous error from the current location.
There are, of course, many other features as well.
I love and hate unit testing. It's a fantastic idea that I've never seen successfully implemented in practice, mostly because the tests invariably fall by the wayside. At the very least, it's a burden to support them.
I'd love a tool that would observe my code during runtime - capturing all inputs and outputs from every function, as well as the value of each variable at each point in the execution flow. Because this would probably incur a performance hit, I'd want to have the option to toggle it on/off.
After execution, I can scroll through a list of called functions and decide which ones I want to save. Once I choose to save, the tool generates a unit test for the selected function. Since the tool is capturing I/O of all functions, it could retroactively mock each call within the function.
This would only be useful for deterministic functions, of course, and it would still be up to devs to document why the expected results are what they are. But my goodness it would be a time saver - one click unit tests. Yes please.
Yet, this would be amazing for legacy projects with no unit tests: you could record the code in production, and generate unit tests from there, and add them to the non-tested project.
It would bring you a safety net allowing you to better work on that legacy project IMO.
This actually reminds me a an attempt at an internal tool I saw pass by whose goal was to save all IO for a given request (aka db call, log calls, network request, file read) for a given backend, and allow you to replay those locally for testing purposes independently from the language used by the backend. I think this didn’t lead anywhere, because it was harder than expected, some things couldn’t be recorded easily (like RNG use), and it also meant finding a way to have all IO libs use the precomputed values.
Plus, the very act of engineering in a dependency injection for the mock if not already provided, enforces a testable interface.
After execution, I can scroll through a tree of called functions and convert it into permanent "implementation documentation" (saved in a document I can annotate eg. with data flow, and edited when the code itself changes), helping me understand both the structure and dynamic control flow of code I'm learning or relearning after months of absence. I currently do this manually in Google Doc bullets, in order to make sense of legacy code whose control flow is fragmented into many function calls I must piece together mentally (as described in http://number-none.com/blow/john_carmack_on_inlined_code.htm...), and as a starting point for restructuring types and function graphs.
Suture is geared towards refactoring, so it doesn't do it for every function at once, and instead you have to specify methods manually.
https://playwright.dev
Are you using object-oriented programming or a more functional style? Without classes, unit tests become a lot more readable and manageable.
I use Deno and its standard library for testing with Puppeteer. I've found unit tests overrated and scenarios underrated (ie testing pyramid).
https://docs.microsoft.com/en-us/visualstudio/test/generate-...
Also known as its legacy / research project name, "Pex". The underlying algorithm technique is called "dynamic symbolic execution".
There was also similar tool for Java called "Agitar Agitator".
It's an interesting idea for sure!
https://github.com/Azeirah/autotest
There's a class of integration tests dubbed consistency tests, which tracks the output that an interface provides give a specific input in production, and the test consists of playing back a sample of said production traffic to verify if the service remains consistent before promoting/dialing it up in production.
This class of integration tests is also used in UI tests, and Selenium provides explicit support for them.
https://elementalselenium.com/tips/62-web-consistency-testin...
Our Show HN: https://news.ycombinator.com/item?id=31286126 Our demo: https://www.youtube.com/watch?v=aD4CV7UL0RM
Would love to get your feedback.
But if you like working on developer tools, the best way to do it is to find a sufficiently large company that care’s sufficiently much about developer tools that they will be willing to pay you to work on in-house developer tools. This can be much more stable than trying to sell developer tools yourself (hard to find a tool with market appeal and hard to sell it) and you get to easily talk with your users and understand what they actually want. People are also much more tolerant of teething problems with internal software than with external software.
A lot less buggy.
Sheesh.
But is is crazy buggy. It's also YUGE. It's only exceeded in size, by games.
Also could we get documentation on things like Instruments? I don’t just mean stuff like “this button opens the whatever pane.” I mean how do you use it and what does its output mean? I’ve rarely seen such useless documentation. (Well, Unix man pages, I guess.)
A fully integrated Vscode extension that can "time travel" the app state (just like React Native Debugger standalone app does, but for the whole app not just redux).
Visual way to debug/replay/disable/change speed of animations that are applied on objects, with animation values and dependencies also listed with their realtime values (perhaps that could be progressed with a slider).
Visual way to display fragment shaders on an image/3D model, at a pane.
Just a few that came to my mind.
“View Source” used to be a career-starter for a lot of people, but has become largely useless today due to transpilation, frameworks, and other abstraction layers.
I’d love to see a browser extension provide an “Explain Source” context menu item, which sends you to a pane in Developer Tools that shows:
- an estimation which frameworks the page is likely using (a little like the bar chart that GitHub shows for languages);
- a list of dependencies that the website is likely pulling in, with links to their respective homepage and GitHub page;
- their version number(s), if detectable;
- language(s) in which the website was likely written; and
- a small internal API so people can contribute recognition rules for more frameworks and libraries via pull request.
The target demographic would be students of all ages (starting at elementary school), and other people who’d love to learn about web development but don’t quite know where to start.
And who knows, bringing back that explorative, hands-on philosophy may well help a single person get into web development – maybe on the other side of the planet? – and I believe that’d already be worth the effort.
And, most importantly: fully offline (so you can be sure nobody learns about the sites you visit).
One (lengthy) nitpick based on a word you used:
> estimation
From that, my guess is that you're implying that because of the spaghetti-pile of bundled JavaScript, CSS and HTML that we have nowadays that it's not possible to use predictable, well-defined standards to make this information available to users.
And you're probably right, it's a mess!
But I would suggest that we try hard to figure out better ways to make the technology simple again, and move towards those, rather than building a complex guess-the-technologies layer on top.
Ideas towards that:
- Move (standardized) package metadata into JavaScript modules themselves so that the data can be inspected and surfaced at runtime (status: I'm not aware of this being standardized, but it may be)
- Improve the ability and mechanisms available to import JavaScript modules (status: this is happening gradually)
- Remove the requirement for applications to perform any bundling at all (status: there's recognized frustration and maintenance burden regarding bundling, but I haven't yet seen no-bundling solutions arising)
- Reduce the need for minimization of content served over-the-wire on the web (status: debatable -- it's probably still required for now, because particularly JavaScript, even after compression, can be fairly large and may still be served in low-bandwidth environments)
A key benefit of this "re-simplify the web" approach would be that as well as enabling the explorative, hands-on approach you suggest, it should also make the learning curve easier for the resulting newcomers.
Many websites’ code now are minified so I have to copy and paste it around then manually clean it up before I can start reading it.
and I'd love to see this for git repos. like "what-is" command that explains what is in a repo based on files structure and content, what modules and glues are involved. it's impossible to keep up with dependencies these days, especially for someone like me who doesn't code in the freshest stacks on the regular...
- webpack bundle analyser
Use it to determine what’s in the bundle. Can give you insight into tools, APIs and other dependencies.
- shuji
Used to decompile minified js. Effectively you can read the bundle, see the directory structure. Perfect tool for learning.
[1] https://openbase.com/js/webpack-bundle-analyzer
[2] https://openbase.com/js/shuji
I actually forgot we used to do this. I miss the early web.
Today, entr allows you to restart a command when a file changes.
A web server allows you to serve local files to your browser.
If you use npm, lots of libs allow you to serve your web ui, and make the browser reload the page when something has changed.
But this is tied to npm, and even to the framework you use (eg: angular has its own way).
It would be cool if we could have a way to do that for any tool/language. Like, could a tool tell the browser to reload, because that tool was restarted by entr due to a file change?
This would allow live preview on any kind of files, or maybe even program output in the browser without having to press F5 every time.
[0]: https://github.com/clibs/entr
https://github.com/cortesi/modd
https://github.com/cortesi/devd
https://www.npmjs.com/package/livereload
https://github.com/guard/guard-livereload
if you search for livereload + whatever framework/language you use, you will probably find an implementation that integrates nicely. but the cli works just fine for anything, really.
1. A tool for debugging TypeScript (in VSCode) that shows the provided and expected types, and how they are different, in a way that is easy to read.
Instead of having a bunch of nested paragraphs in plain text, show it in two columns, each displaying how a normal person would write a type declaration. Maybe even use color (highlighting?) to show which parts are different.
2. A tool for VSCode that lets you expand (into a modal or whatever) types that are abbreviated when you hover them
https://rust-analyzer.github.io/manual.html#inlay-hints
- A dependently typed programming language like Coq [2] (or Agda, Idris, Lean, etc.) that is sufficiently approachable to gain enough mindshare that companies start adopting it for mission-critical work.
- A version control system which scales to petabytes or more. Something that I could put large video files in without thinking twice about it. Something a large company could use for their monorepo—or even their data warehouse.
- A note-taking tool that allows me to organize notes in a graph with links between them (like a wiki), not as files and folders in a tree, which enforces the invariant that every note is transitively reachable from some "root" (by following links) so I never lose a note.
- Something like Toast [3] but which is also designed for running services in production, not just local development and continuous integration. A unified way to run code in dev, test, and prod environments. A new k8s.
[1] https://nixos.org/
[2] https://coq.inria.fr/
[3] https://github.com/stepchowfun/toast (shameless plug)
Working on it :)
> - A version control system which scales to petabytes or more. Something that I could put large video files in without thinking twice about it. Something a large company could use for their monorepo—or even their data warehouse.
https://github.com/facebookexperimental/eden
> A note-taking tool that allows me to organize notes in a graph with links between them
https://www.orgroam.com/
I look forward to checking it out when it's ready!
There is a class of note taking apps that's becoming increasingly popular (at least I perceive it that way) that does this. They store notes in local Markdown files, and when you link between pages, they can build and render a graph based on them. For example:
- Obsidian: https://obsidian.md/
- Logseq: https://logseq.com/
- Joplin: https://joplinapp.org/ (not sure if it's built-in, but there's a plugin: https://github.com/treymo/joplin-link-graph)
Have you tried Bazel? It has warts but has been improving for a long time.
Git Annex might work here
- A polished window manager (e.g., Yabai) written using Hammerspoon modules
- Hudson (Jenkins) replacement (self-hosted) written in typed Python
Does Cucumber (https://cucumber.io/docs/guides/10-minute-tutorial/), Fitness (http://fitnesse.org/FitNesse.UserGuide), and similar abstraction frameworks meet your need?
> Hudson (Jenkins) replacement (self-hosted) written in typed Python
No offense, but this seems squarely in the "I want a faster horse" camp. To say nothing of the fact that the existing Jenkins is written in a statically typed language
Also, I would like to show selected function or variable names in bold or larger fonts.
Viz. Knuth Warp/Weft.
- Sets constraints on how we write code - like a combination of a powerful linter and templates or patterns.
- Visualizes code-base and flow of code - quickly navigate to the relevant code as well as show the available functions in the code-base so newly onboarded devs can more easily re-use code than write new functions.
- Press record to capture 3rd-party requests and store as json mocks to use with a Mock Service Worker (msw)
Anything that improves the feedback loop, visualizes code-base, reduces context-switching or simplifies flow of code.
Storybook keeps impressing me. It's often misunderstood as a documentation tool but it's more than that. It let's you:
- develop components in isolation, greatly improving the feedback loop and sets constraints on what the component takes in as props and what it renders.
- testing for visual, accessability, interactions etc.
We have a collection of existing snippets user can already use in their IDE on the Codiga Hub [3]. Developers can define their own snippets and share them with their team.
We are still developing the product. It works with IntelliJ and VS Code and we have already a lot of users on the platform. Would love to hear your feedback!
[1] https://www.codiga.io [2] https://www.codiga.io/code-snippets/smart-code-snippets/ [3] https://app.codiga.io/hub
It also has a pretty powerful diagramming tool.
[1] https://dstack.ai
It takes space and diatracts a bit.
Bonus points if I could have a, for example "# /assertion_func" comment that would label a whole function to be folded together with asserts.
I'm not sure how useful this would be, but I'd like to try it.
Web Dev is only a distant area of expertise of mine. I find learning new things here not complicated, but a bit tedious.
What I'd like is to be able to scan through html files faster. And what hinders me the most, in terms of reading others' code now, is figuring which html classes are custom-declared, and which belong to a design framework, like bootstrap or tailwind.
Being able to tell at skim-speed would be awesome.