Previous HN discussion: https://news.ycombinator.com/item?id=20475865
At the end of that comment, I wrote "I think we should be doing more of this kind of modelling. Building more accurate maps of the world, and reasoning straight from them, instead of trying to build complicated webs of arguments.".
I still think this is what we should do, and my remarks about Argdown upthread still stand, but since writing this, I actually did try and model the mentioned scenario in a tool for playing with dynamical systems. The end result is here:
https://insightmaker.com/insight/206860/Musings-on-a-HN-comm...
(Press "Simulate" to look at the pretty graphs; note that behavior changes at T=10 years, to demonstrate how the steady state changes after increasing the export target.)
and commentary is here: https://mastodon.technology/@temporal/105044866452071486.
TL;DR: trying to express things as bona fide dynamical systems is very much like coding: there's a wide gap between an idea in your head and a model of a dynamic system that's specified precisely enough to do maths with, and that gap is the space where it's easy to make errors. So I'm no longer convinced models of dynamic systems are a way to improve the quality of discourse within a non-specialized audience.
(The particular problems I faced here were the problems of finding reference data for interesting quantities, and that modelling emissions required domain knowledge I didn't have. I've also made stupid modelling mistakes that I only caught because I decided to sanity-check the model before publishing, and the results didn't match my expectations. Also note that to get the system into a state that could be simulated, I had to use ~4x the amount of nodes I envisioned in the original comment.)
Perhaps there's way forward with better tooling, but I worry this is a problem isomorphic to "low-code": you need a certain level of experience in maths/computation/precise thinking before being able to navigate complex problems, and this probably applies not just to telling computer what to do, but also to any non-trivial social and political problems. In other words: the interesting problems may be intractable to lay audience without upfront work to get them thinking precisely enough - you can't offload this work onto a computer.
I mentioned in the linked thread that I'm not convinced argument maps are too helpful for finding answers to tough questions. I only played with them on Kialo, so it may be me being inexperienced, but for now, I've identified the following problems:
- They don't promote or facilitate expressing the most important things: facts, quantities and probabilities.
- The tree structure is a step up from linear arguments, but it's only an imprefect projection of the underlying graph-like "thoughtspace". A thing I've seen frequently on Kialo was the same argument showing up in several places in the tree, to support or weaken some other thought - and that same argument was supported or weakened by different things in each instance. In a more perfect representation, any argument would show up only once - but that means the representation needs to work with at least directed acyclic graphs.
Some HNers helpfully pointed out that argument maps work as input data (a way to serialize actual arguments people make), and output results (a projection generated from a larger, graph-like thing). This is worth exploring, IMO.
Assuming these two, or some other use cases, I think that yes, Argdown artifacts could be made by expert teams and shared for reuse.
As for unit testing, that's a tough one. What would you unit test against? We could run some sanity checks on the language to ensure that something listed as a "con" is actually a "con" and not a "pro". But going beyond that is, I think, entering the space covered by a bunch of specialty fields that I'll jointly refer to as "symbolic AI" - and IIRC, that hit some serious roadblocks few decades ago. I don't know what's that state of the art of machine-readable reasoning - but right now, I think that unless we can convince regular people to write their arguments as machine-provable theorems, there isn't much we can unit-test beyond superficial language features.
(Part of the reason I think the way forward may be modelling actual systems of interest, instead of arguments about them, is that it automatically forces you to work with artifacts that are concrete and understandable by machines. For instance, when I was implementing the dynamic system I mentioned above, I purposefully opted to use the "units of measure" feature of InsightMaker. This is akin to static typing in programming - suddenly, I had the computer prevent me from making invalid arguments by confusing amounts with flow rates, etc. But of course, nothing prevents one from building a structurally correct model that still has no relationship to reality.)
If two distanced communities could articulate the core of their world views -- and yep, I realize that even within groups, it's never going to be possible to get perfect agreement on what those are -- then the resulting argument trees could be shared with each other and could lead to the possibility of constructive discussion, critique and understanding.