Ask HN: What developer tools would you like to see? | Hacker News Reader

Ask HN: What developer tools would you like to see?

131 pointsavg_dev226 comments

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.

View on HN

Remember the early web, when people used to look at existing websites to learn how it was done?

“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.

That would be great. You could also recommend extensions to be installed if a website uses a certain framework. For example, the react Dev tools extension can be used to view the source of react apps in a more intuitive way compared to the rendered html file.

Good point!

builtwith.com?

A bit like that. But for web dev, not sales intelligence.

And, most importantly: fully offline (so you can be sure nobody learns about the sites you visit).

Not sure what you mean by sales intelligence; builtwith shows frameworks, web server tech, etc.

Ah ok, I stand corrected. Looks like I’ve been misled by their pitch, which focuses heavily on the recon-for-more-leads aspect.

There is https://www.wappalyzer.com/ which does most of what you are looking for.

I use the wappalyzer chrome extension almost everyday when I'm browsing the web, pretty useful at getting a highlevel view of the tech used

Thanks! That’s exactly what I was looking for. It’s even local (data stays in the browser) and free software.

This would be brilliant!

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.

Not only explain the source, but also format and present it in a nicer way.

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.

My experience is; view-source gives the downloaded html (&css &js). It will show a js function which adds some html elements to dom. So for example view-source migjt never show a specific div with text. I usually go by inspect element, because that shows that shows whats rendered, what we actually see on dom.

also to add stackshare.io

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...

I use Builtwith chrome extension for this. Free version is pretty good for most of the use cases. https://builtwith.com/

Another couple of tools that are useful for analysing apps/products that heavily utilise js.

- 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

> when people used to look at existing websites to learn how it was done?

I actually forgot we used to do this. I miss the early web.

I don't know if this exists or not, but it's something I've always wanted.

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.

100% this.

Not sure this would be great for new code, because the tests are supposed to dictate the function’s behaviour, and not the other way around.

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.

Very true, yes. Much more useful for existing code. Although I don't think unit tests and TDD necessarily need to be aligned, the red-green-refactor flow could potentially be re-imagined with a tool like this.

One thing I found useful with Trompeloeil was the tracer. You instantiate a tracer, and then every call made into a mocked object is logged for you. Really make it easy to see how a mysterious controller operates on the thing you are mocking.

Plus, the very act of engineering in a dependency injection for the mock if not already provided, enforces a testable interface.

This sounds like fuzzing. Do you want fuzzing?

I believe a key component of fuzz testing is randomized input. I’m talking about recording live usage of an application and capturing the observed I/O. Like Playwright, mentioned above, but applied to unit testing rather than E2E.

It's not a key component, in fact a lot of fuzzers do intelligent input culling and whatnot based on static analysis.

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, and the call graph. 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 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.

There's a gem for Ruby that does a limited version of this: https://github.com/testdouble/suture

Suture is geared towards refactoring, so it doesn't do it for every function at once, and instead you have to specify methods manually.

It doesn't check all your boxes, but have you tried Playwright?

https://playwright.dev

I've looked at Playwright and it seems to be very close to what I want, but it's on the E2E side. I'm looking more for a unit testing variant of that idea.

> 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.

Are you using object-oriented programming or a more functional style? Without classes, unit tests become a lot more readable and manageable.

So much this, both in the tested code and in the test code itself. I only started unit testing in Python once I discovered pytest; the built-in unit test framework was such a cognitive mismatch for my usual coding style.

Always functional; I'd never try to implement unit testing with classes, that sounds like a nightmare. I'm not talking about the difficulties of writing a unit test, which is where the oop/functional divide is important. I'm talking about the increased time to market, the difficulties of maintaining tests over time, the need to have everyone on the team be equally committed to tdd, etc etc. These are the things that kill good testing practices.

I use Deno and its standard library for testing with Puppeteer. I've found unit tests overrated and scenarios underrated (ie testing pyramid).

A tool similar to what you want. It generates input/output pairs from the code, aiming to maximize coverage, and allows you to convert them to unit tests with one click.

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".

I experimented with this idea in PHP by capturing profiles and traces.

It's an interesting idea for sure!

https://github.com/Azeirah/autotest

> 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.

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...

Ah very nice, that sounds close to what I'm imagining. Will check it out, thanks.

also perhaps note worthy: "instrumentation", which I guess is a part of it at least. very useful tool.

Yeah I want this too. Jest Snapshots are great for quickly saving the expected output and asserting that it doesn’t deviate, but it would be nice to have the same sort of “snapshot” of inputs as well.

I am building Videobug - we record run time code execution and play it back in the IDE. We aim for Quick bug fixes, better code understanding and automatic test case generation.

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.

- A build system / package manager like Nix [1] but with a better user experience / more straightforward command-line tooling.

- 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)

> - A build system / package manager like Nix [1] but with a better user experience / more straightforward command-line tooling.

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/

> Working on it :)

I look forward to checking it out when it's ready!

Did you write nixery?

Yes

> - 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.

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)

> - A build system / package manager like Nix [1] but with a better user experience / more straightforward command-line tooling.

Have you tried Bazel? It has warts but has been improving for a long time.

Whats awesome about nix? I struggle to grasp why is better than docker

> A version control system which scales to petabytes or more

Git Annex might work here

A CLI tool that can be used to observe and act on the return code and/or output of any CLI tool on Linux. It should have a way to notify [1] the user after a long-running CLI program terminates on Linux.

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/

I haven't checked how configurable it is, but on Fedora 35 when you start a long running task in the Gnome terminal and then change the focus to another app, you'll get a system notification when the command in the terminal completes.

yeah i've considered something like this. "send a screenshot to my phone of the terminal when activity has stopped for at least x minutes."

tmux has some facility for this now (although i think there's some weird limitation where it can only be setup for panes and not individual windows), it just needs some scripting to capture the contents of the window and send it off.

ntfy already supports sending messages after long running commands:

    ntfy done sleep 10

If you want to also capture output, you can just use a simple bash function:

    ntfy_done_output() {
        local TEMP_FILE="$(mktemp)" SUCCESS LOG
        "${@}" 2>&1 | tee "${TEMP_FILE}"
        SUCCESS="$((!PIPESTATUS[0]))"
        LOG="$(curl -fLX POST -T- <"${TEMP_FILE}" some-pastebin.example.com)"
        if ((SUCCESS)); then
            ntfy send "Success! Log: ${LOG}"
        else
            ntfy send "Failed :(. Log: ${LOG}"
        fi
    }

You can use Cronitor like this.

1. Create a free monitor and activate an on-complete callback (telegram, slack, or webhook.

2. Install CronitorCli (a single statically linked golang binary)

3. Run any command using Cronitor exec:

   cronitor exec <monitor key> dd if=/dev/sda of=/dev/sdb

Execution history and up to 100MB of output will be logged in Cronitor, including performance metrics, exit codes, etc.

You can be alerted on failure, on success, or on start, or any combination of those.

I was thinking hard about this and truth is I did write code to do it.

From the README.MD in my private repo:

> `ec` prints out the elapsed time and exit code of a command after running it.

But the thing is, Bash supports this natively, using `$?` and you can even put it in your `$PS1` so you see it for every command, or use a function: https://wiki.archlinux.org/title/Bash/Prompt_customization#V...

Still, I like my solution. It was fun to write. If you want access to the repo let me have an email address I can write you at, or a GitHub username, and I'll let you have a look. https://i.imgur.com/DUf9gDc.png

Think of all the dev tools you use (debugging, code navigation, etc). Then pick a literate programming system (e.g. org mode with Babel). How many of those dev tools can you use? In my experience: Almost none.

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.

Oh dear, that last one. The number of times I wanted git to ignore specific changes I've made in config/top level files locally...

First: source maps.

Second: have you tried creating another git repository inside a gitignored directory?

The files I need to track cannot be confined to a single directory. Some of them will coexist with source code files.

Will look into source maps, but the principle applies to all aspects of literate programming. When editing a source block, linter tools go crazy because they see me use variables that to them appear to not have been assigned to (they were assigned to in other source code blocks).

That’s a pretty specific problem. So the linter cannot work on the context of a single file because the lexical scope is spread across multiple files without any kind of import/export or namespacing to dictate which files belong together? If so, then maybe the linter could read all files, cache the scope and partially invalidate it on each update to a file.

I want a tool that lets me annotate a codebase but with the notes stored locally and not in the code. This would mostly be for corporate code bases so I can take notes/ leave more explicit warnings for others.

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.

There's an Emacs mode that does this called annotate. But why would this be better than just leaving a comment on the file?

https://github.com/bastibe/annotate.el

Maybe if you’re working on partially open source code you want a layer of comments separate to the code that aren’t version controlled so you can mention internal bits to each other?

Personally I don't want to have to open the browser to get more detailed docs. I'd rather have it next to the code it's referencing. (Especially if it's just a side project where sphinx or whatever is overkill.)

This isn't explicitly what you're asking for, but it's something: https://plugins.jetbrains.com/plugin/16998-notebook

I'm currently thinking of how to do exactly what you described with intellij plugin's. I've realized, that for me, i'm best when i print out code, use rulers to draw dividers between methods and other stuff, and then take notes for different parts of the code.

don't mind the horrid writing that's most likely unintelligible: https://i.ibb.co/ByTm7vt/notes.jpg

I've always wanted something similar to git blame for this. Where I can add notes to sets of lines and toggle whether I want the IDE to display them. Sort of like writing on those overhead projector sheets and saving it to a nearby .notes file or whatever. It'd probably be hell to maintain but a dev can dream.

Tangential, but it sucks that it's hard to even find discussion on something like this. Closest I've found is the fictional "an editor" talk here https://www.destroyallsoftware.com/talks/a-whole-new-world

Aren't there tools that suggest, based on commit history "you edited x, and people who do edit y and z"?

Jetbrains IDEs have this feature, however I can't find any other documentation other than this StackOverflow question on how to disable the feature:

https://stackoverflow.com/questions/59105219/how-to-get-rid-...

This is exactly what we're building at https://usecodex.com ! We've got an extension on the VS Code Marketplace if you'd like to check us out

> 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 assume you’re being concerned specifically about the tone and style of your copy possibly coming across as maybe too casual and not professional enough. Please don’t be concerned.

A corporate environment doesn’t mean your inline or block comments need to be polished, bureaucratic, or conforming to some style policy. Whoever reads your code and comments is going to appreciate a helpful hint just like you and I would.

If I came across a block comment that told me the thing you mentioned, chances are I’d just feel grateful and appreciate the simple, no-bullshit guidance you afforded me.

I have written an internal tool where I work that does this for our DevOps/Platform/Infrastructure repos. Basically, you annotate the code, and the annotation points you to somewhere easy to update (Confluence etc.) where you can add notes about the code.

Multiple files, repos etc can have the same reference, so when a CI pipeline runs for a PR on any repo, you get a nice PR comment showing you a tickbox-list of all the other places in the org where this reference exists for you to look at and to make sure you're not breaking something elsewhere, along with a link to wherever observations about this reference are written in prose.

VS Code -> Line Note extension

https://github.com/tkrkt/linenote

All the tools I want to see already exist. The big problem I have is that I can never perfectly configure IDEs or any other tools to work with my project unless y project is exceedingly simple.

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.

I feel your pain. I love vs code but sometimes I miss classic visual studio. I know it still exists but vs code is awesome for better or worse. the problem is it aims to be the swiss knife of development environments, everything is extensible and sometimes it's overly complex rather than simplifying. they need to rework their extension store imo. not sure what but feel like unfulfilled potential.

I would love to see tools in these categories:

- 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.

For templates and patterns, we started Codiga [1] where you can define smart code snippets [2] that depends on your environment and can be parameterized by the user when being inserted.

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

Intellij Ultimate does the first two already. You can create new inspections using structured search and then mark any matches as errors. I've done this to make usage of one or two awkward APIs safer. Or you can quickly write a bit of new inspection logic if your inspection can't be expressed using a structured search. Those can be stored in tree.

It also has a pretty powerful diagramming tool.

Can you elaborate on "reduces context-switching"? I am working on something around that, but it can mean different things based on context.

Find a way with entr[0] and an http server to tell the browser to reload the currently viewed file if it changes.

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

If I'm understanding you correctly, then this combination of two tools from the same author will get you that:

https://github.com/cortesi/modd

https://github.com/cortesi/devd

Actually nice! Thanks! (Only works for html files, but that’s already good)

http://livereload.com/

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.

many projects allow web reload, see python httpwatcher for example.

Intellij does this (for html files at least)

Emacs merged with Pharo, not because of Smalltalk but of the GUI part, or being able to have a modern GUI inside Emacs native (no EAF) producing widgets in Emacs Lisp normally, so being able to have live widgets (custom included) in org-mode buffers.

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.

A truly "next generation debugger" as replacement for gdb, lldb and the MSVC debugger which allows me to watch my program working in realtime (and pause/step/rewind at any time). Visualization should include things like a memory-read/write/execute heatmaps, a realtime flame-graph profiler, a data structure browser which "knows" the entire program state, and a much tighter integration of such a debugger into the regular edit-compile-test workflow.

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).

Building something like this to work with existing code in compiled languages is REALLY HARD. However, take a look at rr and Pernos.co.

Yep, I'm aware of both projects, also RemedyBG is a step in the right direction.

I agree it's hard, but it's been hard for the last 3 decades, but not much has happened (with the exception of time travel debugging).

I think debugging tools are just not deemed important enough by many programmers, which is a bit of a shame. Also they require support from compilers, operating systems, and hardware, and this level of integration is hard to achieve - maybe Apple could do it if they had any interest in good debugging tools.

This is called time travel debugging right? https://en.wikipedia.org/wiki/Time_travel_debugging

It's one step in the right direction, but as far as I'm aware it's still too awkward to use (e.g. AFAIK it requires a separate recording and debugging session), ideally I should just be able to hit the "Run" button in my IDE, and have "time slider controls" which allow me to pause and rewind on the fly, while seeing the visualized program state update.

If you are doing web development have a look at http://replay.io

More image based development. Developing against the running program. Ability to debug unhanded errors in real time while you fix them. Like how you do with Lisp/SLIME.

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.

Yes! I actually have a specific app in mind that if I had the time/patience I would build. Better yet if you build it I will buy it!

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 am working on a tool I'm calling Makerflow[1] that covers your github PRs and upcoming meetings use cases. My big picture aim is to work towards a system that makes it easier for devs to do do deep work, collaborate effectively, and manage their cognitive load.

[1] https://makerflow.co

I appreciate the heads up.

I've checked out the landing page. I didn't see any docs for the various tools. Is that something forthcoming?

Yes, docs on the website are upcoming. Meanwhile I have some documentation on github for the cli [1] and vscode plugin [2]

[1] https://github.com/makerflow/cli [2] https://github.com/makerflow/vscode-plugin

I think we all agree that we want faster horses.

And that would be meaningful feedback when we talk about cyborg hourses that OP can try making it faster unlike horses as a species.

I believe my point was that asking users is… tricky.

I think we all agree that we want ways to crank out React faster.

An IDE that provides a linear view of your code base. Follow code paths as though they were all inline, e.g. expand views of function/method internals inside the calling function, etc. No more changing files/modules.

forever now I've been imagining a codebase as database, functions/expressions are entries and the IDE can query based on context, eg. filter by regex or other rules and filter differently when debug context available etc.

it should be transparent once you flatten the db to file(s) and run normally, but for IDE would need to be aware of this db structure. maybe a VS code extension might work!

that is the dream...

How is that not describing just a regular IDE like Intellij? The reason it has an indexing phase when you open a new project is because the IDE is building a database of your code base. You can then do many kinds of query against it.

I'm not aware of it. any examples/links?

https://www.jetbrains.com/idea/

They make IDEs for many languages but the indexability of languages varies a lot depending on (mostly) how strong their type system is and how easily parsed the code is. Check out their structured search feature for an example of how to do semantic queries over the indexed AST.

CLI / TUI parsers and analyzers of code. Let's not compartmentalize those into super-complex graphical IDEs.

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.

Interesting. What are the limitations associated with current tooling, e.g. described at https://kadimi.com/cli-refactoring/ and https://waylonwalker.com/refactor-in-cli/ ?

The limitations are that these are very plain regexes. I've screwed up a good amount of time doing that, it's not good enough. We need actual structured semantic analysis, the way the compiler / interpreter does it.

This sounds like a great use case for Tree-sitter ( https://tree-sitter.github.io/tree-sitter/ )

GitHub uses Tree-sitter for code highlighting and goto definition, so it already has grammars for many languages

Sure, but that's a library AFAIR. I am talking about an actual CLI tool.

Thanks for the link! This looks interesting. I agree with the parent comment that we need better tools. Perhaps this would be a good starting point.

I could see 1 and 3 not being too hard to build using treesitter[0] Too bad, I don't have time to build it

[0] https://github.com/tree-sitter/tree-sitter

Yep I know, there are various CLI LSP tools and then you have awesome tools like `rust-analyzer`.

What I am lacking is a complete tool you can command to do specific isolated actions.

A debugger like RemedyBG, but for linux and macos. Bonus points if you could use it for all the things, including but not limited to: WASM, javascript, android, and iOS.

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

TypeScript stuff:

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

Agree on 2 if you meant something like inlay hists in rust-analyzer.

https://rust-analyzer.github.io/manual.html#inlay-hints

For #2 you can hold CTRL when hovering over a type to expand the type definition. If you hold CTRL+click it will go to the definition.

This video [0] is from February 2012, but as far as I know this tool is not yet implemented (or at least it is not widely used).

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.

[0] https://www.youtube.com/watch?v=PUv66718DII

This gets pretty close for web applications: https://www.replay.io/

Another relevant talk: https://www.youtube.com/watch?v=Ml6Dp3F4Inc

I want a code hosting service that deploys a Dockerfile to both a web app/api and a queue/cronjob using http endpoints. I can attach Postgres databases (fork, restore), caches, file hosting, static files, email to the web app/apis. It should scale to zero (in bill too) if a request/job is not running and autoscale. It should alert me of performance issues and errors. It should also have a domain manager so it can map to our domains or have a custom myservice.myuser.hostingservice.com with HTTPS, WAF, CDN. Currently I have to set them all manually in Google Cloud Run. Render and Fly.io are also progressing.

Some kind of vulnerability tracker for dependencies. You type `gradle somecommand` and it will walk the dependency graph, incl all transient ones, and show you which dependencies currently have an active vulnerability affecting them and the version that fixes it.

Isn't that what dependabot does?

snyk does exactly this. You can also integrate it with bitbucket so automatically make PRs with upgraded package versions.

I've wanted a way to track the full context in which code was written or updated for years now.

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.

I'd find it nice to have a VS Code plugin to hide assertions. Specifically in Python, I see myself writing asserts to check for data boundaries, numpy array sizes, data types.

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.

Keyboard-focused text editors. Reaching for the mouse pointer is super annoying, unless I'm using an undocked macbook (which itself is an ergonomics nightmare). Emacs and Vim are fine enough, but both are old software with plenty of baggage. I don't find Vim's mnemonics comfy or intuitive, and Emacs' performance is abysmal by text editor standards. I believe more competition in the space, especially from big players, would yield significantly better software. But right now, it seems that the big players have settled for command pallettes that get them 90% of the way there, which for me just made the remaining 10% stand out more. I hope Zed[0] changes this.

[0] https://zed.dev/

There is also terminal based Helix: "Helix's editing model is strongly inspired from vim and kakoune, and a notable difference from vim (and the most striking similarity to kakoune) is that Helix follows the selection → action model."

https://helix-editor.com/

Does vim mode in IDEs cover your use case?

Working in a team I think it'd be awesome to see when other people are editing the same files in a project- which could help spark conversation and avoid merge conflicts.

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).

>Working in a team I think it'd be awesome to see when other people are editing the same files in a project- which could help spark conversation and avoid merge conflicts.

Sounds kinda like Google Docs for devs

A proper TypeScript debugger for React Native + Vscode that fully supports async, stepping in TS (instead of falling back to .bundle files randomly), breakpoints (instead of randomly deciding not to break) and sagas (generator functions).

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.

I don’t have any great ideas. A big one for me would be ‘better/much faster language server for the language I use’ but that’s a lot of work.

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.

Do you have any tips on how to find such companies? I've always wanted to work on developer tooling but only ever found one company willing to invest in that.

Any big tech company will invest in developer tooling. E.g. Google has tens of thousands of software engineers. They have internal build systems, internal source control, internal code review, internal code search, and so on. Facebook is similar. Microsoft make and sometimes sell developer tools to be used outside their company.

Make web development experience in 2023 like desktop development experience in 1998.

Can you elaborate on that? I'm a bit young to have done desktop development in 1998. What aspects of it do you miss?

I’d like to see RAD tools, WYSIWYG editors (that don’t generate awful code), one-click build/deploy without any yaml. I feel like the big cloud providers are really under-invested in this area.

JSX templating engine for Node.

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.

This is fully supported - you can substitute your own JSX runtime implementation for React's, either in your @babel/plugin-transform-react-jsx config (specify the 'importSource' directive) or on a per-JSX-file basis using @pragma.

Im building dstack [1], a tool for continuous training ML models in the cloud. And I’m looking for a co-founder! Happy to chat if you are interested.

[1] https://dstack.ai

What capabilities should your cofounder have?

Ideally, experience of building or selling tools to developers. Understanding of MLOps scene would be a bonus. Desire to build great tools!

I would love an IDE where I can create documentation formatted as tables, colors, graphics etc. directly in the source code comments.

Also, I would like to show selected function or variable names in bold or larger fonts.

Viz. Knuth Warp/Weft.

This would be awesome! I can’t stand ASCII art. I can rarely tell what they’re trying to draw and it looks awful.

Yes! Rendered markdown comments - especially with mermaid or equivalent diagram support and the ability to link to functions/classes/etc - directly in the IDE would be amazing!

Lazydocs and mkdocs can take python docstrings and renders markdown into a documentation website. Given it's just a sphinc website, you could probably then also add plugins for mermaid, plantuml, etc.

I just want Xcode, but less buggy.

A lot less buggy.

Sheesh.

lol yes. Really, I just want an XCode without all the cruft of an IDE. Like what VSCode is to VS.

XCodeCode? :)

Well, I like a lot of that "cruft." Things like Storyboard Editor, autocomplete, DocC, Instruments, etc.

But is is crazy buggy. It's also YUGE. It's only exceeded in size, by games.

You could try AppCode (personally I ended up preferring Xcode despite all its pain points, I can’t really get on with Jetbrains tools, but YMMV!)

I tried it. It was too much like Eclipse, for me (I am not an Eclipse fan). But I know a lot of folks that like it.

So much this! And faster. Why does single stepping take visible seconds and cause visible redraws of all the panes in the debugger? WTF? It wasn’t this slow when we had 25MHz CPUs running GUIs, why is it so slow now? (Yeah, systems are more complicated, but they’re also a hell of a lot faster and have more CPUs to distribute the work around!)

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.)

I wish to resurrect the spirit of the Fox/dbase family of languages. I start from the bottom with a language more on line with data manipulation: https://tablam.org.

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.

A tool that lets non software developers manage data-driven tests. I've been in many work situations over the years where the product manager / business stakeholder wants to test something (it could be an API endpoint, or even sometimes just a method or algorithm). From a developer perspective, it's the same code running every time, just with different inputs, and asserting different outputs. From the business side, each test is a different use case that they need to test (and some are more critical than others).

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).

Such a tool exists. Check out https://hexawise.com/

Git alternative that works with GitHub but isn't git

Try Jujutsu https://github.com/martinvonz/jj

isnt't git good enough? didn't get your point

git sucks completely. after using it for a decade, even building it (light demo) from scratch to get a feel for it, watching courses after courses and using it daily.. I still can't memorize most of it which is because UI of commands doesn't make sense....

wanna create a branch git checkout -b "abc"

wanna see what branches you have: git branch

wanna revert to file to old state: git checkout c5f567 -- file1/to/restore file2/to/restore

I thought checkout was to work with branches? what happened?

why is there even staging?

why there are infinite flags

I just want to have different version/branches of same code so i can try different things and go back and forth between them, plus remote sync.

I get by with common commands and if situation is weird either I will find the solution by Googling or I'll have to manually copy paste new code.

Fossil, technically, if you write functions for converting to/from git automatically to push/pull from github

Do you fancy re-thinking buf trackers? I'm looking for help over at https://github.com/MichaelMure/git-bug to create a distributed bug tracker embeded in git, with bridges.

It's close to be ready for prime time, yet there is so much that could be done to make it better.

Log viewer that can prettify JSON structured objects. And for example if you clicked on level = error it can quickly filter all error logs.

CloudWatch is basically that.

I'm pretty sure you can do this with Kibana as well.

While others are replying with ‘this or that already does this’, I totally feel you. All the log viewers I’ve worked with (latest ones being DataSet and Kibana) have some holes in their UX. When that compounds with badly configured log pipeline it’s really painful.

I think I have a prototype you might be interested in, but I´d like to manage expectations first :)

  - It isn´t finished
  - The code is a mess (and not available online)
  - The UX clearly needs work 
  - etc. etc. :)

...but I started a thing with basically exactly the same gripes as you two. The only difference: Actually, I don't think collapsing JSON is nearly enough. I want pretty printers (like in GDB) I can rewrite on the fly.

So, 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/

> I want pretty printers (like in GDB) I can rewrite on the fly.

This hits very close! Will have a look at this for sure, thanks.

For my tiny projects, I analyze my JSON logs with:

- 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

The Logfile Navigator is a TUI for viewing/analyzing log files and will pretty-print anything with a keypress, see https://lnav.org/features#pretty-print-view

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.

https://www.visidata.org/

Awesome, this comment section has turned into a goldmine of already-existing, amazing developer tools that I wasn’t aware of.

An open source, downloadable and fine-tunable github copilot openai codex model that I can use locally and offline, if I wanted to.

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.

Make a faster Swift compiler. Way faster.

I think something that relates to the pain of onboarding with unique configurations for core tools used by developers would be useful.

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)

At an old job I spent my first week on the job documenting the process from a wiki page into a bash script (albeit with some comment sections that said "do this manually"). A year later, one of our devs was up for a laptop upgrade and I convinced him to give Linux a try. I shared my script with him and he was up and committing code later that afternoon. The next week we had a company wide mandate to switch to linux for dev laptops.

Point is that just taking the tiny step of forcing this from a wiki page into code can tip things towards automation. The real difficulty is keeping those scripts up to date. I'm still working on a solution for that (hopefully I'll have something to share in the next few weeks).

Yeah, this was my problem (we have many Mac users so my liberal use of 'xdg-open' wasn't appreciated (I'm sure it was more than that I didn't have a Mac to test it against'.)

A move to devcontainers helped this but dictated some ide behaviours (majority of devs are tried and true jetbrains people) so changing they way they use their tools made this a 'no sale' so again like the wiki my scripts sit idle. But I dream for the day a `curl ${url} | bash` can solve these teething issues

At times, I have wanted a text editor that uses a "scroll and zoom" interface for navigating a single, long file. The minimap idea is similar, but I want it fully integrated into the main view.

I'm not sure how useful this would be, but I'd like to try it.

I love that idea, some kind of Google maps for code where (0,0) is your main would take out a lot of pain when onboarding into large and poorly documented codebases.

Yeah, that is exactly the situation I was in when I really wanted it.

A Reference Counted, Prefix Counted, String library for C.

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.

3D graphics especially interactive interfaces is still far too complicated, presently needing to be build over layer upon layer of libraries and toolkits. I think a simpler approach will be a good thing to have for developers.

What do you mean by layers? Vulkan, opengl, metal, directx, etc are all pretty low-level APIs. They’re complicated to use, but architecturally simple (at least from the end user perspective)

In a way I mean that these libraries are low level.

Spline.design is great.

I think there are already too many tools, always learning new ones seems to take more time the gain of using them. Instead I would like to see people use more common sense and taking responsibility of the quality of their code.

Haha making new tools is easier and in some ways (at least short term) more rewarding

what I personally would like to see is a tool that helps me to undererstand the codebase. Maybe a sourcecode visualizer.

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.

I wish there was a module bundler like Webpack or Parcel that was not super nondeterministic. Something that Just Works(tm), where error messages are consistent+predictable, and configuration isn't a nightmare.

A toolkit that inputs HTML, MarkDown, PDF, or any other "markup" language and separates out the Text, Layers of Markup, Images and Code.

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.

I'd like an app which generates interesting new developer tools.

I feel like this must exist and I just haven’t found it, but I’d love a tool that can automate seeding a staging/local db from production.

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.

Maybe you're looking for this: https://github.com/Qovery/Replibyte.

The holy grail for me would be a tool that allows me to run (basically) any Python package in the browser.

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 would love to see another tool like the platinum tech inc "Repository" The tool would scan your C/C++, Fortran and Cobol code AND scan your databases and then allow you do to pretty sophisticated analysis. Such as "If I change the type of this column in my db where will it cascade down in to my code." They were eventually acquired by Computer Associates after I left the org but I've not run into a tool like it since.

If you can take up a brownfield project, try to make the debugger for Rust better.

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.

A test tool that can take an abstract/general purpose AST and output unit tests for every code path. Complementary features would include pinning tests to 1. Diff 2. Detect regressions. Also having the ability to fuzz the code automatically would be great.

A command-line tool that displays the changelog and diff between current-local and latest-upstream versions of all dependencies would be useful.

In other words: "pip list --outdated" but with a changelog and code diff for each dependency.

A C++ IDE that is fast, feature-rich, responsive, bug free and supports C++ 20.

I've been looking for a language agnostic documentation tool that uses tags in code comments to provide function parameter type hints, etc. Something like JSDoc but available across any language.

visual debuggers and a node-based programmatic tools.

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.

Multi language dataflow analysis to debug and communicate how data goes through a system.

AI image to html/CSS. I hate fiddling with css keywords when I already know what I want it to look like.

AI to css hehe not a terrible idea. of course overkill compared to insert web builder here, but cool idea nonetheless.

Perhaps add javascript to godbolt?

[1] https://news.ycombinator.com/item?id=31470251

- Language agnostic unit test framework

- A polished window manager (e.g., Yabai) written using Hammerspoon modules

- Hudson (Jenkins) replacement (self-hosted) written in typed Python

> Language agnostic unit test framework

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

Perhaps buildbot as a Jenkins replacement https://buildbot.net/

When inspecting HTML elements in the Developer Console I would love to see which TypeScript file it was generated from (and which line)

Would like to see a FLOSS IDE good enough to wrest mindshare back from vscode. A competitive stronghold that shouldn't be dominated by BigTech and telemetry.

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.

Are you aware of VSCodium (https://github.com/VSCodium/vscodium#readme) and does it not meet your criteria because it's "dominated" by Microsoft?

The rest of the terms such as "responsive," "easy to use", and "no unique interfaces" make your request hard to fulfill

Correct, should not be built by the first company in line to yield to the NSA while hungry for data. Also, ...

Re: hard, not at all, there are many responsive floss development tools already. They just need some extra polish, community building, and not be written in Java or Javascript, etc.

Probably needs some sponsorship to build mindshare, that seems the harder part. If too big a request (from scratch) one could start with an existing one and add plugins wrapping existing floss dev tools and language servers at a lower priority.

I want a tool, when deployed to my kubernetes cluster, displays all of the documentation from `kubectl explain`, but in a web app.

Chrome Dev tools allowing to mock a specific URL with a local file or replacing parts of it to point to a localhost mocks service.

intervene.dev does effectively this.

Replacing a GET URL with a file is supported natively with local overrides in Chrome's DevTools. https://developer.chrome.com/blog/new-in-devtools-65/#overri...

Cross-platform (i.e. Mac) systemd journal file viewer.

Currently you can only view the log files on Linux using journalctl.

WebObjects but you only need a browser.

a better remote application debugging tool. and a better way to debug and track a serverless applicaiton

Maybe a tool that would compare snippets of code with others and find the most efficient one?

instant hot-reloading Rust compiler

Perhaps using guard you can automate that https://github.com/guard/guard

TL;DR: highlight tailwind / bootstrap classes in VS Code.

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.

You can use the Tailwind CSS IntelliSense VSCode extension for this.

I would just like the see the suckier parts of VSCode be fixed (to my liking ... meaning I get that different people have different preferences)

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

Dunno dog. I'm a developer. If a tool is missing then I just build it for myself. I'm happy with this arrangement.

sheeeesh

Reply on news.ycombinator.com