“View Source” used to be a career-starter for a lot of people, but has become largely useless today due to transpilation, frameworks, and other abstraction layers.

I’d love to see a browser extension provide an “Explain Source” context menu item, which sends you to a pane in Developer Tools that shows:

- an estimation which frameworks the page is likely using (a little like the bar chart that GitHub shows for languages);

- a list of dependencies that the website is likely pulling in, with links to their respective homepage and GitHub page;

- their version number(s), if detectable;

- language(s) in which the website was likely written; and

- a small internal API so people can contribute recognition rules for more frameworks and libraries via pull request.

The target demographic would be students of all ages (starting at elementary school), and other people who’d love to learn about web development but don’t quite know where to start.

And who knows, bringing back that explorative, hands-on philosophy may well help a single person get into web development – maybe on the other side of the planet? – and I believe that’d already be worth the effort.

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

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.

- 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

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.

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

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

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.

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

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

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

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.

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

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.

It's an interesting idea for sure!

https://github.com/Azeirah/autotest

https://playwright.dev

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

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

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

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)

Working on it :)

> - A version control system which scales to petabytes or more. Something that I could put large video files in without thinking twice about it. Something a large company could use for their monorepo—or even their data warehouse.

https://github.com/facebookexperimental/eden

> A note-taking tool that allows me to organize notes in a graph with links between them

https://www.orgroam.com/

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

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

Git Annex might work here

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/

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

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

    ntfy done sleep 10

    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
    }

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.

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

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.

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

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

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.

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

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

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

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.

https://github.com/tkrkt/linenote

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

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.

We have a collection of existing snippets user can already use in their IDE on the Codiga Hub [3]. Developers can define their own snippets and share them with their team.

We are still developing the product. It works with IntelliJ and VS Code and we have already a lot of users on the platform. Would love to hear your feedback!

[1] https://www.codiga.io [2] https://www.codiga.io/code-snippets/smart-code-snippets/ [3] https://app.codiga.io/hub

It also has a pretty powerful diagramming tool.

Today, entr allows you to restart a command when a file changes.

A web server allows you to serve local files to your browser.

If you use npm, lots of libs allow you to serve your web ui, and make the browser reload the page when something has changed.

But this is tied to npm, and even to the framework you use (eg: angular has its own way).

It would be cool if we could have a way to do that for any tool/language. Like, could a tool tell the browser to reload, because that tool was restarted by entr due to a file change?

This would allow live preview on any kind of files, or maybe even program output in the browser without having to press F5 every time.

[0]: https://github.com/clibs/entr

https://github.com/cortesi/modd

https://github.com/cortesi/devd

https://www.npmjs.com/package/livereload

https://github.com/guard/guard-livereload

if you search for livereload + whatever framework/language you use, you will probably find an implementation that integrates nicely. but the cli works just fine for anything, really.

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

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.

[1] https://makerflow.co

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

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

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

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.

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.

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

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

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

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

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

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

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

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/

https://helix-editor.com/

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

Sounds kinda like Google Docs for devs

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.

[1] https://dstack.ai

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.

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

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

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

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.

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

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.

- jq

- Google Sheets (after conversion to CSV)

- Beekeeper Studio (after conversion to SQLite)

This won't scale to large projects, but it works well for the logs from my little CLI tools I enjoy writing in my spare time.

I wrote about this (with some screenshots) at https://github.com/bbkane/logos#analyze-as-json

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

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/

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

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)

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

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

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.

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

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

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

Does Cucumber (https://cucumber.io/docs/guides/10-minute-tutorial/), Fitness (http://fitnesse.org/FitNesse.UserGuide), and similar abstraction frameworks meet your need?

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

No offense, but this seems squarely in the "I want a faster horse" camp. To say nothing of the fact that the existing Jenkins is written in a statically typed language

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

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.

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