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.
“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.
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.
- 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.
[3] https://github.com/stepchowfun/toast (shameless plug)
It would have similar semantics to the time utility. Let's call this tool timed.
For instance, prefixing any task with the time utility e.g. "time dd if=/dev/sda of=/dev/sdb" would output the duration of the underlying task.
Similarly, executing "timed dd if=/dev/sda of=/dev/sdb" would send a notification to the user when the task completes containing the return code and any console output.
1: Paired with something like https://github.com/binwiederhier/ntfy. This would allow a user to set up multiple ways to receive the notification, including Telegram/Slack, SMS, push notification, email or simply just turning console outputs into a continuous audio note similar to http://listen.hatnote.com/
A trivial example: Running the tangled code, and getting errors. I know the error is in line 1234, but how do I map that line number to the line in some particular code block?
This is the primary thing holding me back from serious literate programming. Plenty of opportunities here.
The other thing I want (which I'm sure someone has solved): Having "orthogonal" repositories within a repository: Say I clone a Git repository. I want to now store some personal files in those directories (notes, config files for linting tools only I use, etc). I want these version controlled locally, but they should never be pushed to remote.
Another one: Get me ways to read tool/framework/language docs as Info files, so I can view them offline and via Emacs. Sphinx based docs can be built with a texinfo target.[1] Find some other tool that generates docs and add a texinfo target to it if it doesn't exist.
[1] Although it has warts.
Less "Turns markdown into react components" and more "If you have to touch this, you need to go to file x, add it there"
I understand this is imperfect but so is the codebase I work on.
Let me give you just one example. VSCode + Python has a little tool for integrating with unittest/pytest. It’s pretty neat. There’s a little GUI where you can run your tests in the left panel.
But what if it’s a Django project? Even if you are using unittest, this thing no longer works because django doesn’t invoke the tests directly, but through manage.py. They have no official support for this. You can hack around it, but not without downsides.
Now lets’s say it’s not only a Python/Django project, but also an AWS/CDK project. You’ve got a bunch of typescript in there. And you have the CDK tests as well as the Python/Django tests. The tooling just isn’t able to handle any project beyond the most basic. I always find myself just reverting to the old vim+bash dev environment, as that’s what works.
I want to see an IDE that actually understands and works perfectly with complex projects as well as it does with the most basic ones.
- 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.
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.
And yes that's a "developer tool" because with both Emacs and Pharo (witch means classic user-programmable desktop environments, because that's what they really are) using a desktop is actually programming it as a normal daily activity where some just automate boring stuff, some others do a bit more complex automation in various shade of grey toward "system level" programmers, all with the same environment and work model instead of IBM-like (originally that's was) compartmentalization/separation of anything to make more profit and makes people feel powerless just impeding them to easily mold their own environments, at any level, programmers included.
As it is now, debugging is still stuck in the 20th century (I realize that the "realtime part" is hard to do, and may require to get the compiler and even hardware peeps on board too).
I think this is the best way to develop hands down. But its flown under the radar through the entire 90's era up to the present.
The problem is this: in any given day as a developer I'm creating information in any of a dozen or more systems. Outlook (emails), Jira (tickets), Confluence (Wikis), Github (PRs), Slack (DMs and group messages), Notion (notes), IntelliJ, GDocs, etc.
All of these systems have a part of the story of how features/projects are developed, sustained, maintained, and altered.
All of these systems have their own search functions that vary widely in quality.
I want a desktop app that will allow me to search across ALL of my "developer" applications from a single pane.
In particular, I want "magic text" links to work in each app. For example, if I see TICKET-1234 then I want the app to know this text links to a particular Jira ticket.
Once you have this as a basic app you can turn it into a platform. This app could help me organize my day as a developer, and remind me of things I need to do.
I would eventually want this app to show me: * github activity and PRs I need to review (or let me set a reminder to review them later) * upcoming meetings * set a watch on particular repos, paths, or files to tell me if something has changed
I'm not concerned about this app having editing functionality. Having great search is the most important thing.
I'd like to be able to do e.g. `$TOOL functions path/to/module.rs` and get a flat list with only names or full function signatures (configurable by CLI switches).
I'd also like to have some pre-baked analyzers e.g. find all controllers in Rails / Phoenix / Laravel / ActixWeb projects. Or all views, templates, etc.
Furthermore, CLI/TUI refactoring please! I want to rename a function, or a module, or even just a local function variable, let me do it!
In general: tooling for massaging source. We need much more of that.
To clarify: I use Vim as a text editor. I use it for all of my programming editor needs no matter what I'm making. I also make a large variety of things because I'm a consultant. Vim has never let me down as far as being able to intelligently edit everything from React to assembly and everything in between on every desktop OS. I'd like a debugger that is suitably small, fast and flexible.
https://remedybg.itch.io/remedybg
Here's Casey Muratori demonstrating all the way in which RemedyBG rocks. https://www.youtube.com/watch?v=r9eQth4Q5jg
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
Basically as you are writing a function, you can write sample input for it, and it tells you the intermediate value of each variable inside this function, which lets you reason about the code, makes it trivial to know you've done something wrong, and would make developing a much more interactive experience overall.
In my experience, this is done by hand when writing a function, but a tool like this would make it automatic.
This would track and save all resources that were accessed as events. I mean online and offline documentation, specs, pdfs, architecture diagrams, code examples and other parts of the codebase, Jira tickets, bug reports, application screens and output, tests run, failing tests, compiler errors and emails. Everything that the human took in as input before outputting that code. What was Bob looking at when he wrote this line of code? If you had been sitting next to him that week, what would you have seen?
When looking at code, a recommendation engine would show that context, using event data and view frequency to compute relevance.
To do this properly would likely need an isolated developer environment separate from any personal use. Another option would be some kind of ML that would filter out irrelevant events or give the developer a chance to manually edit this data at commit time.
A simplified version of this would track the web resources accessed and allow the developer to manually insert additional links, notes and documents.
This is a tool I would pay for. Call it Retrace.
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.
[0] https://zed.dev/
A more advanced "Find usages" in IDEs that could perhaps create a graph and show more than just one level deep, or where you can track a function's argument to see where it originated and where it travelled through to get to a function.
A project management tool that could help with covering different scenarios - like a tree of possibilities, and allow you to select which possibilities a card must cater for, the ranges of arguments etc.
A GUI Devops tool for creating infrastructure as code (E.g. for pulumi scripts).
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.
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.
This isn't necessarily all that difficult to make since Babel can already transform JSX for you. I just want to use JSX as only a templating engine, not with React. I'd use it with Express and Alpine.
Also, I would like to show selected function or variable names in bold or larger fonts.
Viz. Knuth Warp/Weft.
A lot less buggy.
Sheesh.
But what they have is integrated REPL + Jupiter-like Command Window + UI Builder. It was a "low-code" kind of tool way before the idea of today, but also a real, full-featured, serous pro-developer environment.
I have just done data-driven tests (i.e. put their inputs/outputs into a data structure and have my testing framework loop through them). But I hate having to sit and copy/paste their inputs/outputs every time they think of a new use case. I'd love a UI driven tool where they can manage all the tests like in a spreadsheet, and when they make updates, my regression tests picks up their tests automatically. Would be nice if it even gave them reports based on what they want to see (e.g. organizing the tests by category, or by severity).
It's close to be ready for prime time, yet there is so much that could be done to make it better.
So far I can't rely on copilot because at any time for any reason they can cut off access or change the functionality. Also, the waitlist.
A requirement of the GPL is that they are supposed to release the model but so far I have been unable to find it. There's some kind of "debate" about this but the GPL is absolutely clear in this regard. I'm confused.
copilot is awesome for (lazy) senior devs who want the no-code experience, meaning not having to look up easily forgettable things. How many times have you've forgotten RegEx or how to check for a file exists in bash? Simple put "#Check if file 'filename.txt' exists if not error" and it will complete the bash line. Convert dates in javascript without going to the mdn docs, etc.
To be specific I wish I didn't have to forward a developer to an already obsolete wiki page then nod and smile as they complain/tussle with the experience/vernacular/context of a document that has no owner.
I think this is a bigger problem (which could be mine and mine alone as everyone seems to really like wikis) but I think being able to seed the developer environment with all the tooling config could help stave off (some of) this pain.
So my thoughts: a simple cli related flow gen tool which could generate this interactively. (And could also verify correctness)
Tools that I can think of from the top of my head that need to be configured to handle user config and private repo location(s) are git, docker and mvn/gradle/npm (etc, I figure all package management tools usually need this).
I like the way https://github.com/trailofbits/algo Works to collect configuration in this respect (Using ansible) as well as how eslint does it (I think using https://github.com/gkz/optionator) For setting up base config in the cli.
Anyway hope this helps seed an idea or at least might identify a problem (not sure how lucrative it would be though)
I'm not sure how useful this would be, but I'd like to try it.
That is, automatic reference counting of strings, to eliminate manual memory management, and avoid garbage collection.
Counted Strings (with a \x00 on the end for compatibility) solve problems with binary data in the string.
Prefix Counting means that the beginning of the structure is BEFORE the pointer, so that if you just reference the pointer, you get the first character of a "normal" null terminated C string.
Using the "cleanup" attribute support of modern C, it should be possible to make a Defer macro to allow strings going out of scope to be dereferenced, and if their reference count goes to zero, deallocation.
When I need to start on new projects with existing codebase I would love a visual map or something of all the components in the source code (before I dive into the sourcecode itself and spend hours or days to understand how everything works together. Personally I need this for php and javascript. I use xdebug profiler for php but thats too much info and I need to run the webapp. I need something that is able to anazyle and visualize the code without executing it.
All the markup should then reference the range of the characters in the text being marked.
If the text is edited as a set of transforms, you can then apply the same transforms to the ranges, and in effect, edit any marked-up format.
Having the layers separate makes a lot of things easier.
When you're done, you could flatten things back out into any of the supported formats.
It would need live in a vpc to access the prod db, but then expose itself to access slices of anonymized data that can be used to restore external dbs.
Essentially a configurable pgdump that includes the ability to anonymize personal info, take recent slices of data, and serve the data all in a way that still protects direct access to the original data.
Pyodide is at the point where it can run any pure Python wheel out of the box, but building non-pure wheels (e.g. containing C, C++, or Rus) is a very manual process.
I don't think we're tooo far away from having tools that automate all the manual work, but I really wish we had them today.
I am currently using CLion and sometimes I can't even print values, it is that bad. I would like to be able to call functions from the debugger.
Perhaps I set up something wrong, but it would be really nice if users of vscode and CLion just can start debugging and then call functions.
In other words: "pip list --outdated" but with a changelog and code diff for each dependency.
the former should be able to convert code to graphs and the latter should produce code from graphs.
see Luna programming language, or other nodes based systems especially in 3D/VFX like blender, houdini, nuke, etc.
for visual debugging I'd like to get graph explorers and instrumentation tools for asynchronous logging (but on debug level, rather than logging embedded in code) and visual cues for dataflow and events, etc.
I'd love to spare a little bit of time I have to experiment with such ideas if anyone is down.
AI image to html/CSS. I hate fiddling with css keywords when I already know what I want it to look like.
- A polished window manager (e.g., Yabai) written using Hammerspoon modules
- Hudson (Jenkins) replacement (self-hosted) written in typed Python
Wishlist: should be very responsive, powerful, and reasonably easy to use. CUA keybindings, no unique interfaces. All intelligent functions running in low priority background threads/workers so the main window is snappy as hell.
Perhaps written in something like rust to improve geek credibility... but if you started with a popular option today and forked, that might be fine.
Currently you can only view the log files on Linux using journalctl.
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.
1. Give me keyboard macros (emacs) https://www.emacswiki.org/emacs/KeyboardMacros
2. Select modes. #1 generally is better with a start selection, end selection mode. As in Start recording, search for `(`, start selecting, search for `)`, copy, do something, paste.
3. Fix the Undo. AFAICT the undo feature in VSCode was made with zero thought. I don't know if it just undoes the last N keystrokes or what it's criteria area but IMO it fails to even try to do what a user (me) would want compared to the editor I used previously which seemed to have some heuristics. (undo cursor moves in groups? undo single words?) I don't know what it's algo was but I never had to retype stuff where as in VSCode I'm always having to retype stuff as undo undoes too much. Another nice feature if my previous editor was I could undo to the last save by just holding Ctrl-Z/Cmd-Z and when it hit the last save it would pause with a prompt. I found that super useful. VSCode I have to close the file (and therefore lose undo/redo past the save) or I have to just super carefully undo and try to remember where the last save happened. 3b. wish undo undid the last multi-cursor addition.
4. Add true column selection/virtual space. Multi-cursor mode is great but it doesn't handle many cases the column selection does. https://github.com/microsoft/vscode/issues/13960
5. Fix the broken "go to" (search result, definition, etc...). In most editors when you choose to "go to" a search result (search all, click a result) the editor shows the result in the active window. Example: Search for "name-of-method", results show the definition and the declaration in the same file. Open 2 windows, make one window active, click the definition in the search results, the active window "goes to" the definition. Click the 2nd window, click declaration in the search result, the 2nd window goes to the declaration. Now you can reference both. This doesn't work in VSCode. In VSCode clicking the 2nd result will move the first window making it frustrating to try to reference things in the same file. They added that you can drag the search result to a specific window but unfortunately there are tons of other places in the editor that default to moving whatever window is already showing that file, rather than the active window. So, if you were trying to see something in that window and had chosen different window as to where you wanted the result to appear you're S.O.L. No other editor I've used in 40yrs has had this (arguably) broken behavior.
Yea, I know, submit PRs