Llogiq on stuff

Design Space Map

The Rust community currently appears to reconfigure its design process. There is some discussion around RFCs. A topic that comes up is shared summaries. I think this is a great idea and want to share my 2¢ here.

Most of the proposals as I’ve read them roughly follow a mind-map style (interesting; my first proposal when the topic came up was to look into mindmaps) that still somehow capture the back-and-forth we often see play out in the RFC comments, yet in a more distilled form. Basically it’s a list of solutions with pros and cons. What set this post of was Niko’s above-linked post to which I tweeted: “[…] I wonder if the pro/con distinction is inherent in the design process or might create needless antagonism we could avoid with a different setup?”

So let’s have a look at how a map can look like and perhaps we can find an antagonism-free (or at least reduced-antagonism) design. Each point on the map represents a possible solution. Solutions will have common points, similarities and differences. So if we imagine the solution space as an N-dimensional space, a common point would be an alignment along one axis. Similarity would be short distance between two points along one or more axes. Differences are planes through the solution space, where a decision we need to make will leave us in one or the other region. Overlaid (or mapped) on this space is a projection of the points into a set of “values” the solutions might help or hinder, according to their benefits and tradeoffs.

So however we present our map, it should declare (or even better, define) those values we try to optimize. I personally feel that this area of solution space mapping is underdeveloped as of now. Especially reuse of values should certainly be improved. One example of such a value would be “consistency”. Note that I present this value without judgement – some people will prize it, while others might deem it less important than other values, say “control” or “turn-around time”. Rust has already committed to a set of core values that should be prioritized, so we will want to write up a good definition of each. We should probably note where value axes are perpendicular (or unrelated), where they may conflict and where there may be synergies waiting to be exploited.

Now that we have spanned the space to search in, we can either focus on sets of solutions or decisions (or subsets thereof). We probably want to do both and switch between the two modes during the process. So we best have a way of marking a solution according to the decisions that circumscribe its position on the map, and to find the decisions that allow for a certain solution. We also likely want to map both decisions and solutions to the values they (likely) optimize or pessimize.

(Aside: I should note that decisions need not be binary – there may be any number of possible outcomes we want to distinguish)

Even better search functionality would allow us to find adjacent solutions and tautological or contradictory decisions. We could also look at the “negative space” (decisions where no solution was entered on one side) and share (or find out) why we see no solution there. One might train a neural network to find interesting “holes” on the map. Such a tool might be useful beyond language design, so I think this would be a very interesting project (not that I have too little of those).