[HN Gopher] Ask HN: What developer tools would you like to see?
___________________________________________________________________
Ask HN: What developer tools would you like to see?
My passion is writing developer tools. I like the feedback you get
and the way it shapes the work. It's cool when you can build
software and someone runs it on their own data just a short while
later and has a direct line of communication to you, providing a
tight feedback loop. I quit my job a few months ago and in a few
months I'll have to find a new one. I thought I'd see if anybody
had any ideas for tools they wanted to see written that lined up
with my interests and that I could try my hand at, to see if I
could make a go of working on dev tools for myself before going
back into the job market.
Author : avg_dev
Score : 93 points
Date : 2022-05-22 11:06 UTC (11 hours ago)
| LinasKo wrote:
| 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.
| 65 wrote:
| You can use the Tailwind CSS IntelliSense VSCode extension for
| this.
| MivLives wrote:
| 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.
| Hackbraten wrote:
| > 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.
| vmsp wrote:
| 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
| exdsq wrote:
| 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?
| Frotag wrote:
| 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.)
| _boffin_ wrote:
| 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
| derrickpersson wrote:
| 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
| bsnnkv wrote:
| 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.
| Frotag wrote:
| 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
| aitchnyu wrote:
| Aren't there tools that suggest, based on commit history "you
| edited x, and people who do edit y and z"?
| sebdufbeau wrote:
| 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-...
| hellohowareu wrote:
| VS Code -> Line Note extension
|
| https://github.com/tkrkt/linenote
| tomovo wrote:
| Make a faster Swift compiler. Way faster.
| fswd wrote:
| 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.
| BeetleB wrote:
| 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.
| activitypea wrote:
| 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...
| eurasiantiger wrote:
| First: source maps.
|
| Second: have you tried creating another git repository inside a
| gitignored directory?
| BeetleB wrote:
| 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).
| peterkos wrote:
| 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.
| lifeplusplus wrote:
| Git alternative that works with GitHub but isn't git
| arxanas wrote:
| Try Jujutsu https://github.com/martinvonz/jj
| valeyard wrote:
| isnt't git good enough? didn't get your point
| bjconlan wrote:
| 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)
| steventhedev wrote:
| 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).
| bjconlan wrote:
| 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
| danielvaughn wrote:
| 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.
| madjam002 wrote:
| 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.
| huijzer wrote:
| > 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.
| danielvaughn wrote:
| 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.
| macintux wrote:
| 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.
| jimmont wrote:
| possibly related: * https://umaar.com/dev-tips/241-puppeteer-
| recorder/ * https://umaar.com/dev-tips/248-recorder-playback/ *
| https://developer.chrome.com/docs/devtools/recorder/
|
| I use Deno and its standard library for testing with Puppeteer.
| I've found unit tests overrated and scenarios underrated (ie
| testing pyramid).
| junon wrote:
| This sounds like fuzzing. Do you want fuzzing?
| danielvaughn wrote:
| 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.
| junon wrote:
| It's not a key component, in fact a lot of fuzzers do
| intelligent input culling and whatnot based on static
| analysis.
| spawarotti wrote:
| 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".
| azeirah wrote:
| I experimented with this idea in PHP by capturing profiles and
| traces.
|
| It's an interesting idea for sure!
|
| https://github.com/Azeirah/autotest
| egoburnswell wrote:
| 100% this.
| jiehong wrote:
| 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.
| adhesive_wombat wrote:
| 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.
| danielvaughn wrote:
| 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.
| arinlen wrote:
| > _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...
| danielvaughn wrote:
| Ah very nice, that sounds close to what I'm imagining. Will
| check it out, thanks.
| high_byte wrote:
| also perhaps note worthy: "instrumentation", which I guess
| is a part of it at least. very useful tool.
| nyanpasu64 wrote:
| 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.
| d3nj4l wrote:
| 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.
| thunderbong wrote:
| It doesn't check all your boxes, but have you tried Playwright?
|
| https://playwright.dev
| danielvaughn wrote:
| 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.
| billfruit wrote:
| 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.
| bogwog wrote:
| 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)
| dan-robertson wrote:
| 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.
| cehrlich wrote:
| 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
| tnzk wrote:
| Agree on 2 if you meant something like inlay hists in rust-
| analyzer.
|
| https://rust-analyzer.github.io/manual.html#inlay-hints
| jka wrote:
| 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.
| gmt2027 wrote:
| 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.
| Apreche wrote:
| 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.
| high_byte wrote:
| 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.
| ultra_nick wrote:
| 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.
| high_byte wrote:
| AI to css hehe not a terrible idea. of course overkill compared
| to insert web builder here, but cool idea nonetheless.
| heikkilevanto wrote:
| 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.
| bbkane wrote:
| Haha making new tools is easier and in some ways (at least
| short term) more rewarding
| isaacsanders wrote:
| I want a tool, when deployed to my kubernetes cluster, displays
| all of the documentation from `kubectl explain`, but in a web
| app.
| ayewo wrote:
| 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/
| stonewareslord wrote:
| 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 }
| a-dub wrote:
| 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.
| encoderer wrote:
| 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.
| PhilippGille wrote:
| 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.
| high_byte wrote:
| 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.
| ushakov wrote:
| instant hot-reloading Rust compiler
| aitchnyu wrote:
| 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.
| badpun wrote:
| A C++ IDE that is fast, feature-rich, responsive, bug free and
| supports C++ 20.
| PainfullyNormal wrote:
| 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
| ChrisMarshallNY wrote:
| I just want Xcode, but less buggy.
|
| A _lot_ less buggy.
|
| Sheesh.
| tomduncalf wrote:
| 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!)
| ChrisMarshallNY wrote:
| 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.
| thewebcount wrote:
| 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.)
| danielvaughn wrote:
| lol yes. Really, I just want an XCode without all the cruft of
| an IDE. Like what VSCode is to VS.
| ChrisMarshallNY wrote:
| 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.
| virchau13 wrote:
| XCodeCode? :)
| jacknews wrote:
| I'd like an app which generates interesting new developer tools.
| stepchowfun wrote:
| - 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)
| tazjin wrote:
| > - 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/
| stepchowfun wrote:
| > Working on it :)
|
| I look forward to checking it out when it's ready!
| Cedricgc wrote:
| Did you write nixery?
| tazjin wrote:
| Yes
| PhilippGille wrote:
| > - 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)
| vladdoster wrote:
| - 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
| hdjjhhvvhga wrote:
| Make web development experience in 2023 like desktop development
| experience in 1998.
| PainfullyNormal wrote:
| Can you elaborate on that? I'm a bit young to have done desktop
| development in 1998. What aspects of it do you miss?
| docandrew wrote:
| 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.
| pdimitar wrote:
| 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.
| Diris wrote:
| 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
| pdimitar wrote:
| 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.
| abrichr wrote:
| 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/ ?
| pdimitar wrote:
| 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.
| bbkane wrote:
| 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
| pdimitar wrote:
| Sure, but that's a library AFAIR. I am talking about an
| actual CLI tool.
| rc_mob wrote:
| Dunno dog. I'm a developer. If a tool is missing then I just
| build it for myself. I'm happy with this arrangement.
| k1ll3r wrote:
| sheeeesh
| 65 wrote:
| 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.
| jameshart wrote:
| 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.
| digisign wrote:
| 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.
| GnarfGnarf wrote:
| 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.
| thewebcount wrote:
| This would be awesome! I can't stand ASCII art. I can rarely
| tell what they're trying to draw and it looks awful.
| bbkane wrote:
| 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!
| tinkertamper wrote:
| 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.
| high_byte wrote:
| 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...
| ktzar wrote:
| 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.
| matt_heimer wrote:
| 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...
| bruderstein wrote:
| intervene.dev does effectively this.
| carlbarrdahl wrote:
| 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.
| juli1pb wrote:
| 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
| mredigonda wrote:
| 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
| gxt wrote:
| 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.
| flohofwoe wrote:
| 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).
| Frotag wrote:
| This is called time travel debugging right?
| https://en.wikipedia.org/wiki/Time_travel_debugging
| flohofwoe wrote:
| 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.
| auchenberg wrote:
| If you are doing web development have a look at
| http://replay.io
| nsm wrote:
| Building something like this to work with existing code in
| compiled languages is REALLY HARD. However, take a look at rr
| and Pernos.co.
| flohofwoe wrote:
| 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.
| birkin wrote:
| a better remote application debugging tool. and a better way to
| debug and track a serverless applicaiton
| peterschmidt wrote:
| 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
| heurisko wrote:
| Cross-platform (i.e. Mac) systemd journal file viewer.
|
| Currently you can only view the log files on Linux using
| journalctl.
| bugmen0t wrote:
| I think we all agree that we want faster horses.
| ransom1538 wrote:
| I think we all agree that we want ways to crank out React
| faster.
| tnzk wrote:
| And that would be meaningful feedback when we talk about cyborg
| hourses that OP can try making it faster unlike horses as a
| species.
| bugmen0t wrote:
| I believe my point was that asking users is... tricky.
| greggman3 wrote:
| 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
| kkfx wrote:
| 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.
| can16358p wrote:
| 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.
| LinasKo wrote:
| 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.
| activitypea wrote:
| 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/
| dancocos wrote:
| 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.
| effnorwood wrote:
| alanbernstein wrote:
| 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.
| gxt wrote:
| 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.
| alanbernstein wrote:
| Yeah, that is exactly the situation I was in when I really
| wanted it.
| foobarbaz33 wrote:
| 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.
| mattl wrote:
| WebObjects but you only need a browser.
| Hackbraten wrote:
| 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.
| Snowworm wrote:
| 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.
| Hackbraten wrote:
| Good point!
| junon wrote:
| builtwith.com?
| Hackbraten wrote:
| 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).
| junon wrote:
| Not sure what you mean by sales intelligence; builtwith
| shows frameworks, web server tech, etc.
| Hackbraten wrote:
| Ah ok, I stand corrected. Looks like I've been misled by
| their pitch, which focuses heavily on the recon-for-more-
| leads aspect.
| high_byte wrote:
| 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...
| doerig wrote:
| There is https://www.wappalyzer.com/ which does _most_ of what
| you are looking for.
| gitgud wrote:
| 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
| azhenley wrote:
| 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.
| davchana wrote:
| 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.
| jka wrote:
| 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.
| dmux wrote:
| 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.
| sto_hristo wrote:
| 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.
| alanbernstein wrote:
| Isn't that what dependabot does?
| hendry wrote:
| Log viewer that can prettify JSON structured objects. And for
| example if you clicked on level = error it can quickly filter all
| error logs.
| nikita2206 wrote:
| 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.
| mfrischknecht wrote:
| 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/
| nikita2206 wrote:
| > 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.
| PetahNZ wrote:
| CloudWatch is basically that.
| bo0tzz wrote:
| I'm pretty sure you can do this with Kibana as well.
| bbkane wrote:
| 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
| jiehong wrote:
| 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
| high_byte wrote:
| many projects allow web reload, see python httpwatcher for
| example.
| dingleberry420 wrote:
| 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.
| [deleted]
| frou_dh wrote:
| 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
| jiehong wrote:
| Actually nice! Thanks! (Only works for html files, but that's
| already good)
| mamcx wrote:
| 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.
___________________________________________________________________
(page generated 2022-05-22 23:02 UTC)