18 ms·

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

• tinkertamper 4y ago
  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 4y ago
    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...
    • native_samples 4y ago
      How is that not describing just a regular IDE like Intellij? The reason it has an indexing phase when you open a new project is because the IDE is building a database of your code base. You can then do many kinds of query against it.
      • high_byte 4y ago
        I'm not aware of it. any examples/links?
        • native_samples 4y ago
          https://www.jetbrains.com/idea/ https://www.jetbrains.com/idea/ They make IDEs for many languages but the indexability of languages varies a lot depending on (mostly) how strong their type system is and how easily parsed the code is. Check out their structured search feature for an example of how to do semantic queries over the indexed AST.
• mattl 4y ago
  WebObjects but you only need a browser.
• hendry 4y ago
  Log viewer that can prettify JSON structured objects. And for example if you clicked on level = error it can quickly filter all error logs.
  • PetahNZ 4y ago
    CloudWatch is basically that.
  • bo0tzz 4y ago
    I'm pretty sure you can do this with Kibana as well.
  • nikita2206 4y ago
    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 4y ago
      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 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/ https://pickaroon.github.io/readme/
• tomovo 4y ago
  Make a faster Swift compiler. Way faster.
• danielvaughn 4y ago
  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.
  • egoburnswell 4y ago
    100% this.
  • jiehong 4y ago
    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.
    • danielvaughn 4y ago
• dan-robertson 4y ago
  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.
  • Kaze404 4y ago
    Do you have any tips on how to find such companies? I've always wanted to work on developer tooling but only ever found one company willing to invest in that.
    • dan-robertson 4y ago
      Any big tech company will invest in developer tooling. E.g. Google has tens of thousands of software engineers. They have internal build systems, internal source control, internal code review, internal code search, and so on. Facebook is similar. Microsoft make and sometimes sell developer tools to be used outside their company.
• ktzar 4y ago
  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.
  • bruderstein 4y ago
    intervene.dev does effectively this.
  • matt_heimer 4y ago
    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/#overrides https://developer.chrome.com/blog/new-in-devtools-65/#overri...
• ChrisMarshallNY 4y ago
  I just want Xcode, but less buggy. A lot less buggy. Sheesh.
  • tomduncalf 4y ago
    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 4y ago
      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.
  • danielvaughn 4y ago
    lol yes. Really, I just want an XCode without all the cruft of an IDE. Like what VSCode is to VS.
    • virchau13 4y ago
      XCodeCode? :)
    • ChrisMarshallNY 4y ago
      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.
  • thewebcount 4y ago
    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.)
• rc_mob 4y ago
  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 4y ago
    sheeeesh
• birkin 4y ago
  a better remote application debugging tool. and a better way to debug and track a serverless applicaiton
• bugmen0t 4y ago
  I think we all agree that we want faster horses.
  • tnzk 4y ago
    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 4y ago
      I believe my point was that asking users is… tricky.
  • ransom1538 4y ago
    I think we all agree that we want ways to crank out React faster.
• can16358p 4y ago
  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.
• Hackbraten 4y ago
  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 4y ago
    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 4y ago
      Good point!
  • junon 4y ago
    builtwith.com?
    • Hackbraten 4y ago
      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).
• sto_hristo 4y ago
  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 4y ago
    Isn't that what dependabot does?
  • minkzilla 4y ago
    snyk does exactly this. You can also integrate it with bitbucket so automatically make PRs with upgraded package versions.
• jiehong 4y ago
  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 https://github.com/clibs/entr
  • frou_dh 4y ago
    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/modd https://github.com/cortesi/devd https://github.com/cortesi/devd
    • jiehong 4y ago
      Actually nice! Thanks! (Only works for html files, but that’s already good)
  • dingleberry420 4y ago
    http://livereload.com/ http://livereload.com/ https://www.npmjs.com/package/livereload https://www.npmjs.com/package/livereload https://github.com/guard/guard-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 4y ago
    [deleted]
  • high_byte 4y ago
    many projects allow web reload, see python httpwatcher for example.
• cehrlich 4y ago
  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 4y ago
    Agree on 2 if you meant something like inlay hists in rust-analyzer. https://rust-analyzer.github.io/manual.html#inlay-hints https://rust-analyzer.github.io/manual.html#inlay-hints
  • tmpfile 4y ago
    For #2 you can hold CTRL when hovering over a type to expand the type definition. If you hold CTRL+click it will go to the definition.
• ushakov 4y ago
  instant hot-reloading Rust compiler
  • breakalot 4y ago
    Perhaps using guard you can automate that https://github.com/guard/guard https://github.com/guard/guard
• stepchowfun 4y ago
  - 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/ https://nixos.org/ [2] https://coq.inria.fr/ https://coq.inria.fr/ [3] https://github.com/stepchowfun/toast https://github.com/stepchowfun/toast (shameless plug)
  • tazjin 4y ago
    > - 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 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/ https://www.orgroam.com/
    • stepchowfun 4y ago
      > Working on it :) I look forward to checking it out when it's ready!
    • Cedricgc 4y ago
      Did you write nixery?
• vladdoster 4y ago
  - 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
  • mdaniel 4y ago
    > Language agnostic unit test framework Does Cucumber (https://cucumber.io/docs/guides/10-minute-tutorial/ https://cucumber.io/docs/guides/10-minute-tutorial/), Fitness (http://fitnesse.org/FitNesse.UserGuide 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
  • breakalot 4y ago
    Perhaps buildbot as a Jenkins replacement https://buildbot.net/ https://buildbot.net/
• hdjjhhvvhga 4y ago
  Make web development experience in 2023 like desktop development experience in 1998.
  • PainfullyNormal 4y ago
    Can you elaborate on that? I'm a bit young to have done desktop development in 1998. What aspects of it do you miss?
    • _vdpp 4y ago
      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.
• GnarfGnarf 4y ago
  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 4y ago
    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 4y ago
    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!
  • nobodywasishere 4y ago
    Lazydocs and mkdocs can take python docstrings and renders markdown into a documentation website. Given it's just a sphinc website, you could probably then also add plugins for mermaid, plantuml, etc.
• carlbarrdahl 4y ago
  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 4y ago
    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 https://www.codiga.io [2] https://www.codiga.io/code-snippets/smart-code-snippets/ https://www.codiga.io/code-snippets/smart-code-snippets/ [3] https://app.codiga.io/hub https://app.codiga.io/hub
  • native_samples 4y ago
    Intellij Ultimate does the first two already. You can create new inspections using structured search and then mark any matches as errors. I've done this to make usage of one or two awkward APIs safer. Or you can quickly write a bit of new inspection logic if your inspection can't be expressed using a structured search. Those can be stored in tree. It also has a pretty powerful diagramming tool.
  • bcosynot 4y ago
    Can you elaborate on "reduces context-switching"? I am working on something around that, but it can mean different things based on context.
• peterschmidt 4y ago
  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 https://dstack.ai
  • edimoldovan 4y ago
    What capabilities should your cofounder have?
    • peterschmidt 4y ago
      Ideally, experience of building or selling tools to developers. Understanding of MLOps scene would be a bonus. Desire to build great tools!
• alanbernstein 4y ago
  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 4y ago
    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 4y ago
      Yeah, that is exactly the situation I was in when I really wanted it.
• LinasKo 4y ago
  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.
• LinasKo 4y ago
  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 4y ago
    You can use the Tailwind CSS IntelliSense VSCode extension for this.
• bjconlan 4y ago
  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 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 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 4y ago
    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 4y ago
      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
• Apreche 4y ago
  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 4y ago
    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.
• heikkilevanto 4y ago
  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 4y ago
    Haha making new tools is easier and in some ways (at least short term) more rewarding
• isaacsanders 4y ago
  I want a tool, when deployed to my kubernetes cluster, displays all of the documentation from `kubectl explain`, but in a web app.
• PainfullyNormal 4y ago
  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 https://remedybg.itch.io/remedybg Here's Casey Muratori demonstrating all the way in which RemedyBG rocks. https://www.youtube.com/watch?v=r9eQth4Q5jg https://www.youtube.com/watch?v=r9eQth4Q5jg
• jacknews 4y ago
  I'd like an app which generates interesting new developer tools.
• kkfx 4y ago
  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.
• jka 4y ago
  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.
• ultra_nick 4y ago
  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 4y ago
    AI to css hehe not a terrible idea. of course overkill compared to insert web builder here, but cool idea nonetheless.
• 65 4y ago
  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 4y ago
    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.
• lifeplusplus 4y ago
  Git alternative that works with GitHub but isn't git
  • arxanas 4y ago
    Try Jujutsu https://github.com/martinvonz/jj https://github.com/martinvonz/jj
  • valeyard 4y ago
    isnt't git good enough? didn't get your point
    • lifeplusplus 4y ago
      git sucks completely. after using it for a decade, even building it (light demo) from scratch to get a feel for it, watching courses after courses and using it daily.. I still can't memorize most of it which is because UI of commands doesn't make sense.... wanna create a branch git checkout -b "abc" wanna see what branches you have: git branch wanna revert to file to old state: git checkout c5f567 -- file1/to/restore file2/to/restore I thought checkout was to work with branches? what happened? why is there even staging? why there are infinite flags I just want to have different version/branches of same code so i can try different things and go back and forth between them, plus remote sync. I get by with common commands and if situation is weird either I will find the solution by Googling or I'll have to manually copy paste new code.
  • nobodywasishere 4y ago
    Fossil, technically, if you write functions for converting to/from git automatically to push/pull from github
• billfruit 4y ago
  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 4y ago
    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)
    • billfruit 4y ago
      In a way I mean that these libraries are low level.
  • Sateeshm 4y ago
    Spline.design is great.
• pdimitar 4y ago
  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.
  • abrichr 4y ago
    Interesting. What are the limitations associated with current tooling, e.g. described at https://kadimi.com/cli-refactoring/ https://kadimi.com/cli-refactoring/ and https://waylonwalker.com/refactor-in-cli/ https://waylonwalker.com/refactor-in-cli/ ?
    • pdimitar 4y ago
      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 4y ago
        This sounds like a great use case for Tree-sitter ( https://tree-sitter.github.io/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 4y ago
          Sure, but that's a library AFAIR. I am talking about an actual CLI tool.
        • abrichr 4y ago
• foobarbaz33 4y ago
  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.
• MivLives 4y ago
  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.
  • vmsp 4y ago
    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 https://github.com/bastibe/annotate.el
    • exdsq 4y ago
      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 4y ago
      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_ 4y ago
    This isn't explicitly what you're asking for, but it's something: https://plugins.jetbrains.com/plugin/16998-notebook 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 https://i.ibb.co/ByTm7vt/notes.jpg
  • Frotag 4y ago
    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 https://www.destroyallsoftware.com/talks/a-whole-new-world
• flohofwoe 4y ago
  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).
  • nsm 4y ago
    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 4y ago
      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.
  • Frotag 4y ago
    This is called time travel debugging right? https://en.wikipedia.org/wiki/Time_travel_debugging https://en.wikipedia.org/wiki/Time_travel_debugging
    • flohofwoe 4y ago
      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.
• dmux 4y ago
  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.
• BeetleB 4y ago
  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 4y ago
    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 4y ago
    First: source maps. Second: have you tried creating another git repository inside a gitignored directory?
    • BeetleB 4y ago
      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).
      • eurasiantiger 4y ago
• aitchnyu 4y ago
  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.
• activitypea 4y ago
  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/ https://zed.dev/
  • xgt 4y ago
    There is also terminal based Helix: "Helix's editing model is strongly inspired from vim and kakoune, and a notable difference from vim (and the most striking similarity to kakoune) is that Helix follows the selection → action model." https://helix-editor.com/ https://helix-editor.com/
  • bcosynot 4y ago
    Does vim mode in IDEs cover your use case?
• heurisko 4y ago
  Cross-platform (i.e. Mac) systemd journal file viewer. Currently you can only view the log files on Linux using journalctl.
• ayewo 4y ago
  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 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/ http://listen.hatnote.com/
  • PhilippGille 4y ago
    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.
  • a-dub 4y ago
    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.
  • stonewareslord 4y ago
    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 }
• peterkos 4y ago
  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.
• greggman3 4y ago
  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 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 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
• high_byte 4y ago
  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.
• badpun 4y ago
  A C++ IDE that is fast, feature-rich, responsive, bug free and supports C++ 20.
• effnorwood 4y ago
• fswd 4y ago
  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.
• gxt 4y ago
  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.
• mamcx 4y ago
  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 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.
• gmt2027 4y ago
  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.
• mredigonda 4y ago
  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 https://www.youtube.com/watch?v=PUv66718DII
  • ricklamers 4y ago
    This gets pretty close for web applications: https://www.replay.io/ https://www.replay.io/ Another relevant talk: https://www.youtube.com/watch?v=Ml6Dp3F4Inc https://www.youtube.com/watch?v=Ml6Dp3F4Inc
• digisign 4y ago
  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.
  • mdaniel 4y ago
    Are you aware of VSCodium (https://github.com/VSCodium/vscodium#readme https://github.com/VSCodium/vscodium#readme) and does it not meet your criteria because it's "dominated" by Microsoft? The rest of the terms such as "responsive," "easy to use", and "no unique interfaces" make your request hard to fulfill
    • digisign 4y ago
      Correct, should not be built by the first company in line to yield to the NSA while hungry for data. Also, ... Re: hard, not at all, there are many responsive floss development tools already. They just need some extra polish, community building, and not be written in Java or Javascript, etc. Probably needs some sponsorship to build mindshare, that seems the harder part. If too big a request (from scratch) one could start with an existing one and add plugins wrapping existing floss dev tools and language servers at a lower priority.
• dancocos 4y ago
  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.
• mncharity 4y ago
  Perhaps add javascript to godbolt? [1] https://news.ycombinator.com/item?id=31470251 https://news.ycombinator.com/item?id=31470251
• Vladimof 4y ago
  Maybe a tool that would compare snippets of code with others and find the most efficient one?
• _nalply 4y ago
  If you can take up a brownfield project, try to make the debugger for Rust better. I am currently using CLion and sometimes I can't even print values, it is that bad. I would like to be able to call functions from the debugger. Perhaps I set up something wrong, but it would be really nice if users of vscode and CLion just can start debugging and then call functions.
• qxxx 4y ago
  what I personally would like to see is a tool that helps me to undererstand the codebase. Maybe a sourcecode visualizer. When I need to start on new projects with existing codebase I would love a visual map or something of all the components in the source code (before I dive into the sourcecode itself and spend hours or days to understand how everything works together. Personally I need this for php and javascript. I use xdebug profiler for php but thats too much info and I need to run the webapp. I need something that is able to anazyle and visualize the code without executing it.
• michaelmure 4y ago
  Do you fancy re-thinking buf trackers? I'm looking for help over at https://github.com/MichaelMure/git-bug https://github.com/MichaelMure/git-bug to create a distributed bug tracker embeded in git, with bridges. It's close to be ready for prime time, yet there is so much that could be done to make it better.
• LouisSayers 4y ago
  Working in a team I think it'd be awesome to see when other people are editing the same files in a project- which could help spark conversation and avoid merge conflicts. A more advanced "Find usages" in IDEs that could perhaps create a graph and show more than just one level deep, or where you can track a function's argument to see where it originated and where it travelled through to get to a function. A project management tool that could help with covering different scenarios - like a tree of possibilities, and allow you to select which possibilities a card must cater for, the ranges of arguments etc. A GUI Devops tool for creating infrastructure as code (E.g. for pulumi scripts).
  • warrenm 4y ago
    >Working in a team I think it'd be awesome to see when other people are editing the same files in a project- which could help spark conversation and avoid merge conflicts. Sounds kinda like Google Docs for devs
• guitarike 4y ago
  A tool that lets non software developers manage data-driven tests. I've been in many work situations over the years where the product manager / business stakeholder wants to test something (it could be an API endpoint, or even sometimes just a method or algorithm). From a developer perspective, it's the same code running every time, just with different inputs, and asserting different outputs. From the business side, each test is a different use case that they need to test (and some are more critical than others). I have just done data-driven tests (i.e. put their inputs/outputs into a data structure and have my testing framework loop through them). But I hate having to sit and copy/paste their inputs/outputs every time they think of a new use case. I'd love a UI driven tool where they can manage all the tests like in a spreadsheet, and when they make updates, my regression tests picks up their tests automatically. Would be nice if it even gave them reports based on what they want to see (e.g. organizing the tests by category, or by severity).
  • SnootyMonkey 4y ago
    Such a tool exists. Check out https://hexawise.com/ https://hexawise.com/
• globetro 4y ago
  Awesome, this comment section has turned into a goldmine of already-existing, amazing developer tools that I wasn’t aware of.
• weilandia 4y ago
  I feel like this must exist and I just haven’t found it, but I’d love a tool that can automate seeding a staging/local db from production. It would need live in a vpc to access the prod db, but then expose itself to access slices of anonymized data that can be used to restore external dbs. Essentially a configurable pgdump that includes the ability to anonymize personal info, take recent slices of data, and serve the data all in a way that still protects direct access to the original data.
  • kermire 4y ago
    Maybe you're looking for this: https://github.com/Qovery/Replibyte https://github.com/Qovery/Replibyte.
• thelittlenag 4y ago
  Yes! I actually have a specific app in mind that if I had the time/patience I would build. Better yet if you build it I will buy it! The problem is this: in any given day as a developer I'm creating information in any of a dozen or more systems. Outlook (emails), Jira (tickets), Confluence (Wikis), Github (PRs), Slack (DMs and group messages), Notion (notes), IntelliJ, GDocs, etc. All of these systems have a part of the story of how features/projects are developed, sustained, maintained, and altered. All of these systems have their own search functions that vary widely in quality. I want a desktop app that will allow me to search across ALL of my "developer" applications from a single pane. In particular, I want "magic text" links to work in each app. For example, if I see TICKET-1234 then I want the app to know this text links to a particular Jira ticket. Once you have this as a basic app you can turn it into a platform. This app could help me organize my day as a developer, and remind me of things I need to do. I would eventually want this app to show me: * github activity and PRs I need to review (or let me set a reminder to review them later) * upcoming meetings * set a watch on particular repos, paths, or files to tell me if something has changed I'm not concerned about this app having editing functionality. Having great search is the most important thing.
  • bcosynot 4y ago
    I am working on a tool I'm calling Makerflow[1] that covers your github PRs and upcoming meetings use cases. My big picture aim is to work towards a system that makes it easier for devs to do do deep work, collaborate effectively, and manage their cognitive load. [1] https://makerflow.co https://makerflow.co
    • thelittlenag 4y ago
      I appreciate the heads up. I've checked out the landing page. I didn't see any docs for the various tools. Is that something forthcoming?
      • bcosynot 4y ago
        Yes, docs on the website are upcoming. Meanwhile I have some documentation on github for the cli [1] and vscode plugin [2] [1] https://github.com/makerflow/cli https://github.com/makerflow/cli [2] https://github.com/makerflow/vscode-plugin https://github.com/makerflow/vscode-plugin
• talivonhuth 4y ago
  When inspecting HTML elements in the Developer Console I would love to see which TypeScript file it was generated from (and which line)
• mikewarot 4y ago
  A toolkit that inputs HTML, MarkDown, PDF, or any other "markup" language and separates out the Text, Layers of Markup, Images and Code. All the markup should then reference the range of the characters in the text being marked. If the text is edited as a set of transforms, you can then apply the same transforms to the ranges, and in effect, edit any marked-up format. Having the layers separate makes a lot of things easier. When you're done, you could flatten things back out into any of the supported formats.
• mikewarot 4y ago
  A Reference Counted, Prefix Counted, String library for C. That is, automatic reference counting of strings, to eliminate manual memory management, and avoid garbage collection. Counted Strings (with a \x00 on the end for compatibility) solve problems with binary data in the string. Prefix Counting means that the beginning of the structure is BEFORE the pointer, so that if you just reference the pointer, you get the first character of a "normal" null terminated C string. Using the "cleanup" attribute support of modern C, it should be possible to make a Defer macro to allow strings going out of scope to be dereferenced, and if their reference count goes to zero, deallocation.
• darshbhatt 4y ago
  [dead]
• rewq4321 4y ago
  The holy grail for me would be a tool that allows me to run (basically) any Python package in the browser. Pyodide is at the point where it can run any pure Python wheel out of the box, but building non-pure wheels (e.g. containing C, C++, or Rus) is a very manual process. I don't think we're tooo far away from having tools that automate all the manual work, but I really wish we had them today.