Argdown – a simple syntax for complex argumentation
argdown.org
argdown.org
I wrote up a paper on the results of an initial usability study: Socratrees: Exploring the Design of Argument Technology for Layman Users (https://arxiv.org/abs/1812.04478)
Still work in progress, but still in progress!
Unlike other argument technology my primary focus is claim reuse, and supporting negated forms of claims. Underlying arguments for a claim and its negation are naturally bundled together. I also have some stricter requirements on 'valid' claims in the system to make this work, and to encourage reuse so that more canonicality can be achieved.
Edit: I might have mis-parsed your comment, although that might not have been clear from my question. I now guess you were expecting tools that assist with CLI argument representation. That's an interesting area too, but Argdown is intended to represent natural language propositions that people can debate.
Would be nice for the https://explainshell.com/ guys too
https://github.com/mkdoc/mkcli
One of these days i would like to rewrite it in Go or Rust.
I even got around to generating bash/zsh completion scripts from the generated program descriptor.
I can picture documenting the stuff with your tool, then one click and POP! All you need is the implementation.
As a visual artist who finds that insights beyond the limits of language are often as valid and interesting as those within it, the opportunity to state a case, and then see and engage it in another visual form is an exciting use case for HCI.
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.
We're swamped with biases, and emotion tends to lead the direction to where we seek our "facts". And it sounds like I mean it politically. But I don't. This feature is overwheling with us except for in the pure natural and measurable sciences. 2+2=4, done. But it ends there when it comes to rational decision making based on objective arguments.
Everything you do privately, what phone you buy, car, where you live, how you pick your spouse, strategy for kids and all the other important things. Also at work, who you hire, where you decide to work, how you rate your colleague, technologies, business strategy, relationship with your boss.
I've almost given up on rational argumentation and objective truth - and have identified the emotional and irrational as being the true battleground for decision making in our existence.
Rant over. Sorry. Argdown is great im sure :D
I think there's an opportunity to add diagrammatic structure to make debate more understandable and accessible, while reducing distractions and (potentially time-wasteful) repetition of talking points.
It's part of a broader idea: take an important topic, and imagine all the ways that bad actors might try to disrupt debate about that. Then try to figure out how to build a discussion system that is resilient against those efforts, while remaining participatory.
(I'd agree I don't think any file format or system will let us reach rationality or objective truth any time soon - if they're even achieable goals - but they could help groups make decisions and debug prior mistakes and misunderstandings)