When I start working on a new project I often start by breaking the system into a few large parts and then incrementally defining the details inside those parts. I do this recursively, working on smaller and smaller levels of granularity until the grain-size matches whatever I’m implementing the system in (code, electronic components, Lego, etc.). I’m sure this is a common process used by many people.
However, I’m not aware of any software tools which automate this process as a whole. I use a combination of various generalized tools, various specialized tools and good-old-fashioned pen & paper. This works, but it’s awkward because the tools overlap in some areas, have gaps in other areas and in general don’t exchange information easily. This means time is wasted deciding where one tool should end and another beings, filling-in gaps and translating data between packages. The other problem with discreet, non-compatible tools is that they don’t lend themselves to producing a cohesive history or documentation. If nothing else, they don’t make documenting the work as streamlined as it could be if the tools were designed to work together.
What I have in mind is probably based on an ancient flowcharting software I used back in school called “MacFlow”. This was what you’d expect, a tool for drawing flowcharts on a Macintosh but it had one powerful feature that I haven’t seen since.
In MacFlow, you could double-click on a flowchart symbol and it would “drill-down” into what the symbol represents. If it was a “Predefined Process” symbol, a new worksheet would open where that process was illustrated; if it was an “Off-Page Connector” symbol, the page it connected to would open, etc.
In retrospect this seems like the most obvious feature a piece of flowcharting software could offer, but I haven’t seen it in any other that does this (or if it exists, it’s so non-obvious that I never found it).
Now imagine applying this to a piece of software with the ability to model more abstract systems. For example, if you’re designing a computer you might start with four boxes representing the CPU, RAM, ROM and I/O, connected by a box representing a bus. Double-clicking on the ROM might take you to a view where you could add more symbols to represent the physical arrangement of ROM chips; drilling further displays the underlying gates or a detailed schematic, etc. Drilling-down with an alternate command might take you into the source code for the ROM routines, etc.
At some level things become less abstract and more concrete. For software this could go all the way down to editing and executing code. For hardware you might not be able to go quite that far, but schematic and PCB designs are certainly possible, along with software simulations of the components. The same could be true for physical objects which could be represented as 3D models suitable for fabrication.
Essential to the usefulness of this tool (at least for me) is that it does this with as simple of an interface as possible. Again MacFlow is a great example of this because it had very few features beyond laying-out and connecting a handful of standard flowchart symbols. Within this seemingly simplistic interface lie a number of intuitive or quickly learned features that allowed the user to create (and modify) complex designs quickly. This is an area where almost all contemporary tools I’ve used fall flat.
So I’m wondering if anyone has already built something like this? It seems so obvious to me that there has to be something out there, but when I think about how software is created (and more generally how products are created) I can see how something as generic and expressive as this might not fit into an existing “vertical” and therefore get overlooked. I can also see how had a system like this been created, it could be quickly absorbed by one particular vertical market who then “improved” it with a bunch of market-specific features which made it no longer useful for other things.