What are some tools you wish you had while doing your day to day work?

I wish I had tools that were just a little smarter at working with code. There are some things that I find I have to manually track down in a large codebase, but the things I do could be automated. I'm thinking of operations like the following:

* Tell me where in package (or module) X it calls functions that can eventually reach function Y in package Z (that is, there is a possible stack trace starting in X that leads to Y.

* Recursively expand the tree of callers of this function.

* Show me where the value passed to this function are created.

* List what packages have functions that can get called when I call function X.

* Given two functions A and B, what functions can result in calls to both? (This is sort-of the greatest common denominator of possible stacks leading to A and B)

(It seems like this must surely exist, but I have yet to find it)

I also want better tools for tracing what a system does when running. For example:

* Say I have a test over some deterministic code, and I make a small change to that code. I'd like to be able to run that test before and after, and get a diff of where the computation was the same vs. where it was different.

* When debugging, I'd like to be able to ask questions about the history, like what set this field on this model to the current value? (With debuggers I've used, you have to know these questions in advance and set up things to watch - you can't ask those questions after the fact)

* List all packages that had a line of code run while running this test.

edit: formatting

I wish I had a way to do knowledge work but also use my body.

Right now, for working purposes (as a software engineer), I'm a disembodied head that can move a pointer, type words, and voice chat. Our bodies were never designed to sit in chairs 8 hours a day for forty years. The very idea of needing to spend free time exercising just to keep your body from falling apart is, well, preposterous.

(It's been a long time since I've watched it, but I think this talks a bit about the idea: https://vimeo.com/115154289 - "The Humane Representation of Thought")

Better documentation. And with better I mean documentation that does not rely on as many assumptions about the reader, and docs that include enough examples. I don't care about that one example which only covers the most trivial use-case that you included so there's an example in the docs. Examples should be like unit tests, I don't want to play the archeologist and dig through pages of outdated info just to figure out how to set that one weird flag.

One example for docs I enjoy is the reference for the Rust standard library. It still could use a few more examples here and there but overall it's among the best I know, together with tailwindCSS' website which is also great.

Don't be like the devs of that one JS animation library which locked further examples behind the registration form for another web platform, failing to mention those hidden examples are more or less a copy-pasted variation with slightly different numbers.

And I haven't thought about it very deeply yet but I'd like a tool or maybe lightweight processing language that lets me quickly visualise debug output and similar data. Often it feels like the main time sink at chasing certain bugs is how I either have to look at the raw data and numbers and try to see a pattern, or more or less start a whole side project to properly process and visualise it. Possibly I'm just missing something obvious or overlooked the usefulness of a neat tool at first glance.

> And it was most frustrating when they had like 100 columns or so. Having to change column 63 at line 58 is not something you do easily in Notepad++. Import to Excel was my way to go, but since the file was not a standard CSV file (e.g. also had sections like an .INI file) it was time consuming: first just select a subsection from the file, save to a different file, import to Excel, modify, paste back, etc.

Suggestion: have you considered learning to use Vim? I imagine most Vim users are reading your example wondering what the big deal is.

Not to take away from the spirit of your post, though. You have valid questions.

A standalone hardware mute switch for Zoom/etc calls so you can prominently and reliably see your mic mute status, and quickly and easily flip it on and off.

(I know there are a few do-it-yourself options for these, but I'd much rather throw a bit of money at it rather than time).

1. A reliable python env manager. Some sort of framework to visualize changes to my env as a visual graph with each update/clone viewable in a git-tree like format.

2. Jupyter lab, but that's as good as VSCode/Pycharm (VS code's jupyter extension is still very lacking. Something like Spyder that's not really a notebook would also work fine)

3. A real Inking->Structure app. Come on. There is money in this. Someone do this. Something that is exportable to any of draw.io/Visio/etc.

On OSX I miss notepad. The dumbest possible text editor. No cloud syncing of notes, no attempt at being optimized for code, no intellisense behaviors, no spell checking or word processor functionality, no WSISWYGness. Just the dumbest possible text editing window to paste things, scratch a few notes, open raw text, etc. I haven’t found the equivalent in OSX even their basic tools are too smart by half.

I would like a tool which allows me to examine Git histories of multiple files in a repo, with some notion of 'distance' between files. So if source file A includes classes or functions which are defined in source file B, then A and B are distance 1 apart (neighbors). B's other neighbors are distance 2 from A and so on.

As an example, I'm looking into a bug which I know is related to file X. I would like to see the most recent change which affects files within distance 5 from X. Or, of all the commits between point 1 and point 2 in the git history, I would like to see the ones which changed files the closest to X.

In another context, for every commit in a release, I want to see how big the n-neighbourhood of the commit is for different values of n, in the same way I can currently see how many files were changed by that commit (the 0-neighbourhood). In all these cases I would want to look at the path of connections between files and what symbols it is based on.

In an ideal world, the 'change distance' and 'change neighborhood' concepts would actually reflect the semantics of what was changed and how it could affect other classes etc. So a whitespace change would have empty neighborhoods since the code in no other file could have been affected. But even with a naive interpretation that any change to a file affects all the linked files would be very useful.

Something I plan on making when free time exists - yet another tool for note organization but with features that I find missing from ones I've seen.

Table stakes:

  - Open source
  - Bring your own client (i.e. you can use any editor as long as data is accessible)
  - Core idea: allows for multiple sources of various types (and makes it easy to add new ones) and then it creates a unified and queryable view over them (via a separate client). Some examples:
  -- Keep notes in multiple files and get a single place I can search over them with annotations of where different pieces come from.
  -- Have source code as a source type. Parse comments that follow the right format to allow smart linking to code for references.
  -- Have the output of tools be source types too, e.g. the output of a grep command.

Bonus features:

  -- Some sort of alerts/notification feature that allows for configuration of trigger conditions
  -- Automatically generated graph view of related concepts / tags / whatever 
  -- Support for multi-user editing with some level of permissioning
  -- LSP support
  -- Editing sources from the unified view (whenever that makes sense)

I wish there was a bi-modal programming language: a "design" mode, and an "implementation" mode.

Design Mode:

    - Define domain model: entities, relationships, constraints
    - Define behaviour: state machines, conditions, triggers, calculations
    - Define architecture: systems, subsystems, modules, interfaces/apis
    - Define rules for composition and communication
    - Define extensibility points, service provider interfaces
    - Define access points: ui, cli, api, lib

Implementation Mode:

    - Map domain model -> db schema, code constructs
    - Map behaviour -> code to evolve domain model/state over time
    - Map architecture -> libraries, executables, services, network topology
    - Map composition rules -> snap-in components from architecture using defined interfaces
    - Map extensibility points -> callbacks, hooks, discovery
    - Map access points -> connect ui/api to model and behaviour

I don't know. I already have them (shell, shell utils, Python, Go, jq, JS, Ansible, etc).

I do what you mentioned all day, every day. I don't like the idea of "a more general product" because that's the power of the tools I use, they are small tools designed to do one or a few things only, but I can chain them together to do complex things. And if one of my small tools doesn't work for a particular task, I can swap it out with or write another small tool.

With your "CSV-like" example, I'd probably do something like grep with a regex to check a line and see if it has more than $x commas, and if it does process the line, if it doesn't ignore it and move on to the next.

I am about to head to a meeting, but something like this:

https://unix.stackexchange.com/questions/249071/check-if-a-s...

I wish I had a robot to do my job for me but still get paid.

When working with React and Redux and Redux Sagas, I wish I could more easily figure out causal chains for what happens. When I previously did work as a game programmer, for most things (except, say, debugging why things rendered a certain way), you could just go to where the thing happened, put in a breakpoint, and you'd get a beautiful call stack making it easy to reason about how you got to where you are.

In my current web development work, using the aforementioned tools, where it isn't just one thing calling the next, but there's a huge amount of indirection and message passing, I have to spend a ton of time figuring out what set of events occurred, and where, and why, to figure out why I got the result I got.

An actual real portable executable format, and standardized build tools. I hate having to jump through build system hoops to target the same piece of silicon with an annoying OS in the way.

Automatically saving and restoring terminals with tabs and separate histories, per workspace.

I have found nothing yet that does this, or even just one of those things. It would be the killer feature of a new terminal emulator - and I see there are lots of them being developed, but none of them have this! And I can guess why: It's because of the maintenance work required to have this feature, and also trying to be multi-platform, multi-desktop and also the work required just to have a working terminal to begin with.

I've been looking for software to map relationships between my team's products (app servers) and their integrations.

E.g. server01 can go from 3.1 to version 4.0 since foo01 integrates with server01 and foo01 supports 3.1 and 4.0.

I have been poking around at graph databases for this, but I'm also looking for something better than wiki pages.

It sounds like you wish you had the classic unix text file utilities like sed, awk, grep, cut, and so on.

Maybe I haven't looked hard enough for these but off the top of my head:

- A universal calendar I can merge across client accounts. As a consultant, I have customers in gsuite, o365, and my personal one and relationship management means manually synching my calendars between them.

- A virtual machine for android phones to sandbox identities and apps into, as I'm not interested in letting a client's MDM near my BYOD mobile.

- A userspace version of Paralells with a linux image that runs on enterprise client's locked down windows thinkpads.

- a Cypher-like graph query language that operates as an abstraction over spreadsheets.

- an excel plugin that de-dups rows and generates Sankey diagrams from selected columns.

An equivalent to excel's record macro functionality, but at the os level, based on what's on the screen using ocr.

Sikuli got close, but something with a little more AI behind it to get a sort of "fuzzy" macro recording.

- A monorepo build tool that handles having a "base" Dockerfile that builds the monorepo dependencies (npm install + npm build) but that then lets sub-images use a subset of the repo easily without needing to re-install/re-build.

- A really nice TypeScript shell scripting setup. I'd like to see Duktape or JavascriptCore used, combine with esbuild/swc, Actually Potable Executable, and ShellJS. Basically, give me a single binary that runs cross platform, so I can write my scripts using TS. Anything to save me from having to continue googling weird bash edge-cases constantly.

I need a visual studio plugin to disable breakpoint breaking while preserving my enabled/disabled breakpoints. Sometimes, I just want to avoid breaking for a bit without removing or futzing with my breakpoints.

I wish I had a tool or app that would successfully get me to reduce both phone usage and use of certain apps or websites. Something that could adapt to different people would be good.

Being able to incrementally load compressed files. Sometimes I have to load large tables, do some processing and save the result. The easiest way to do that has been to load the rows of csv files by blocks (it's really easy to load parts of csv files). But I'd love a way to do the same row wise loading with compressed file formats such as parquet. (Bonus points if that's possible even if I'm not the one who built the original file)

Time-web-browser. That would allow me to look at future webpages and see for example what HNers in 2150 are into. If the sky is the limit of course...

I'd love to have google meet metrics for me and my team so I could easily grasp how much and why are we spending time on meetings.

I think exist a lot of small things to improve of RDBMS, like native support for algebraic types, including a indexable view of enum-rows that could cover a lot of what "unstructured but in fact not" use cases exist.

Also my dream is build a Foxpro/excel like tool to recover what a true effective data-first programming environment can give in modern times.

Probably wouldn't be too hard to do myself, but it love to be able to use the touch bar as a clipboard. Basically have a button that stores whatever on your clipboard at the moment onto the bar making a growing list of tiles, tap on the tile to load it back on to the clipboard, and hold the tile to remove it.

I wish my company offered me a Linux laptop. A Mac is not a solution. Neither is a windows machine.

Can someone create a countdown timer for Ghangouts/Zoom? I find that in most calls time is wasted and people don't usually get to the meat of things until way into the call. A timer for scarcity would make video calls/meetings way more effective

(OP) I woke up this morning and I was pleasantly surprised at the large number of answers to my question. I saw some pretty insightful ideas. Thank you! Also, it would be nice to hear about hurdles that non-software devs are facing.

It may be a skewed opinion of mine, but I think that more value can be added, more easily, by software into other domains, than what can be added by software in software development itself.

Software "divorced from reality" is pretty useless. It becomes useful when: it helps drive a real process (e.g. factories, cars), it helps better understand a phenomenon (e.g. data analysis), provides entertainment or education (e.g. games, animations), gives answers or predictions (AI, machine learning), facilitates communication (messaging, video calls), etc.. A god-like software running in a box (e.g. general purpose artificial intelligence), but not plugged into anything (e.g. at least a monitor, speaker, etc.) will literally offer nothing (even if it could, should it be connected)

Say you make an application to facilitate selling of tickets to a business. Then you may go optimizing the database/website to handle more users, etc. Then you may go optimizing the build-tools, the programming language, etc. The more you continue down this chain (which goes more abstract) the less you directly and meaningfully impact the initial requirement. I'm not saying it's a bad thing! I'm saying:

-> The more "meta" you go, the more broader impact you have on a whole area, rather then just the initial requirement. This is the good part! But also the harder and more complex it gets! Exponentially! This is the "bad" part.

I guess the ultimate point would be to reach general purpose AI. When we get there, the whole purpose of this discussion thread is useless anyway.

But until we get there, I personally think we should focus more (or at least just as much) on fixing the actual problems (in a clean way, with few dependencies), rather then going to deep on that "meta" chain I mentioned. There are good outcomes of course, but one bad outcome of going too "meta" is the increasing bloat and complexity we seem to be experiencing in all modern software.

"Inherent Complexity: The Ways the Problem You’re Solving is Hard" "Incidental Complexity: When Programmers Make Their Lives Worse" https://pressupinc.com/blog/2014/05/root-causes-software-com...

1)Hassle free Copy Paste between workstations on different networks. 2)Generated Ansible from pristine OS to current state.

A modern version of Vern Buerg's List.com. I used that tool in DOS days and almost always had it running.

A thai person to make a feet massage..

Better Google Docs.

It's hella slow.

Python