Screenshot of the Argdown Sandbox

Argunet - a brief look back

We (Gregor Betz, Helen Bohse, Sebastian Cacean, David Schneider, and myself) started working on Argunet back in 2006 and published the first version in 2007 (with funding from the Free University Berlin). Over the years it has been downloaded more than 50.000 times, which is a lot, given the small number of argument mapping enthusiasts and the limited publicity of the software.

But first and foremost, we developed Argunet because we needed such a tool in our own work. And overall it did its job well! We have used it for many different purposes, be it in philosophy seminars, in research projects, for reconstructing huge debates, or for the moderation of live events.

Over time, however, three problems emerged. By design and through the technology used, Argunet is a “monolithic” application:

• Instead of “doing one thing and doing it well”, Argunet tries to be the swiss army knife of argument mapping. This makes it a comparatively large and complex software that is neither easy to use, nor to maintain.
• Because of the technology used, Argunet became more and more difficult to maintain with our limited resources. Argunet is a Java application and uses the Eclipse application framework. Eclipse is known for its complexity and has continuously evolved over the years. Working on Argunet on our free time, we never could keep up, let alone extend Argunet with new features. Differences between operating systems only made matters worse and caused a lot of installation problems.
• Argunet is closely coupled to the Eclipse framework and can not be used as a part of other software that use other application frameworks. Other software can neither directly interact with Argunet nor can its data be read or written without extra export and import steps. Instead, Argunet tries to do everything “on its own”. Additionally, it is very complicated to extend the existing code base with new plugins.

At some point we had to decide if we should rather invest a huge effort into practically rewriting Argunet, or if it made more sense to completely rethink our approach and start anew. We decided to do the latter.

What will happen with Argunet?

As a result of this decision, we currently do not plan to release any new Argunet versions.

This site will remain online and you can still download and use Argunet. If you have installation problems, take a look at the questions asked in the google group or post a new question. We will still try to answer your questions as best as we can.

We are considering, however, to provide additional tools (possibly Argunet Export Plugins) that allow you to save your existing Argunet debates as Argdown files. (If you want to support us in doing so, please get in touch!)

Argdown’s origin story

Around 2012 I started experimenting with combining argument mapping with real-time chat and forum applications. I needed an intuitive way how non-expert users could “augment” their text messages so that it software could extract and visualize the argumentative structure of their discussions. My idea was to define a syntax for text messages that was as easy to use as writing a Twitter message. The inspiration for this syntax was Markdown, so I simply called the new syntax “Argdown”.

While I ultimately abandoned the prototype in pursuit of other projects, Argdown was so much fun to use that we (by now the DebateLab Karlsruhe) finally decided to develop it into a free and open software tool that was expressive enough to let experts logically reconstruct complex argumentation. I released the first version in 2017 and internally we started using it more and more, until it completely replaced Argunet in our work. This week I finally released version 1.0.0 together with an extensive documentation. Argdown is now ready to be used by anyone interested in argument mapping.

What is Argdown?

Argdown itself is not a software, but a syntax. It is a light-weight markup language that is easy to read and write for humans and for computers alike (to borrow a slogan from Markdown). That means that it consists of a set of simple rules how to format text in a text file. By following these rules you can write an Argdown file in any text editor you like.

If you have no experience with markup languages like Markdown, Wikitext or HTML, using a text editor and a markup language to create argument maps can seem daunting and unintuitive. But in fact it is much easier than you might think and has many advantages:

• Easy to learn, fast to use: The basic rules can be learned in three minutes and after that you will already be able to do many things a lot faster in Argdown using your keyboard, than it took you in Argunet using your mouse. Argdown was not invented as toy for nerds. It was originally invented for making argument mapping accessible to everyone. This remains one of our core development goals.
• No distraction: Additionally, using Argdown is not only faster, it also allows you to focus on the essentials. Because you are never leaving your text editor, you can completely concentrate on your writing instead of being distracted by the graphical aspects of your map or the quirks of your editor.
• Easy access: Because they are simple text files, you can merge or split up Argdown files by copy & paste. You can send them as E-Mail or even per text message. You can use a version control system like git to archive different versions of it and collaborate with other authors.

Give it a try! Just read the three-minute introduction on the start page of the Argdown documentation. After that you are ready to play with Argdown in our browser sandbox.

(If you are a “visual thinker” you still might prefer to “draw” argument maps with Argunet, instead of “writing” them with Argdown. In the future we plan to add an Argdown-based map editor that will suit your needs. For now, just keep using Argunet.)

Our new software tools

Screenshot of the VS Code extension

Software that reads and writes Argdown can be implemented in different languages and optimized for different contexts and users. I have written a parser (an Argdown reader) in JavaScript, so that it can run in the browser, as well as on any server or computer (using Node.js). Based on this parser, we have so far released three tools:

• A browser sandbox for demonstration purposes.
• An extension for VS Code, on of the best text editors around. The extension provides a live map preview, code highlighting and many other features useful for editing Argdown documents.
• A commandline tool for advanced users.

Screenshot of the Argdown Sandbox

Our Argdown tool chain is modular at its core, and framework-agnostic. This means

• it can be integrated without much effort into other applications or application frameworks. An example is the Argdown documentation itself, which is compiled from Markdown files containing Argdown code snippets. It did not take a lot of effort to add a plugin to Markdown-It that parses these snippets and inserts widgets with svg argument maps into the compiled HTML files.
• it can be easily extended by adding custom plugins via configuration files without having to wait for new Argdown releases and without having to write your own Argdown application.
• other developers can also develop new tools completely independent of our own tools and still be able to interact with them through Argdown
• because we rely on the syntax and a simple text editor as our user interface we can rapidly release new features and develop new software tools for specific use cases without having to spend time on developing new editing features on the GUI side.

What Argdown can do for you

Right now, Argdown has nearly reached “feature parity” with Argunet and surpasses it in many respects. In this section I will first list features that Argdown shares with Argunet. After that I will list the exciting new capabilities that make Argdown the superior software. Lastly, I will list the Argunet features that Argdown is not (yet) able to match.

Features shared with Argunet

Just like in Argunet, in Argdown you can

• create an argument map that looks similar to an Argunet argument map
• give your statements and arguments titles
• assign short descriptions to your arguments
• quickly sketch attack and support relations between statements and arguments in a debate
• logically reconstruct premise-conclusion structures of complex arguments
• precisely define which premises of an argument are attacked or supported
• group and colorize statements and arguments
• create different views of the same debate
• automatically layout your argument map
• assign multiple statements to the same equivalence class and define logical relations between these equivalence classes.
• export your maps to dot, svg, png or pdf

New features

Unlike in Argunet, in Argdown you can

• tag arguments and statements and automatically colorize them based on your tags
• create hierarchies of groups (groups can now contain other groups)
• quickly change grouping or colorization through configuration without changing the underlying data
• use all the advanced features of a professional code editor: syntax highlighting, code diagnostics (linting), code completion, symbol search, hierarchical document outline.
• focus on rapidly reconstructing and comment your debate in the same text document using rich text formatting, lists and headings for structuring your document, without being distracted by presentational details (colors, layout, grouping)
• use additional relations (contrary, contradiction, entailment, undercut)
• write custom plugins and add them to the Argdown tool chain in your config file
• add arbitrary meta data in YAML format (for use in custom plugins)
• export your data to JSON for further use in other software tools
• export your complete document to HTML
• use version-control systems such as Git to track changes and coordinate the work of multiple analysts

Missing features

Unlike in Argunet, in Argdown you can not

• manually layout your argument map
• export to GraphML and import to yEd for editing
• collaborate online with other users on the same file

The future

We already have a lot of ideas for new features and tools, but we will likely concentrate our work on

• integrating Argdown into different environments and workflows (Embedabble widget for websites and blogs, Markdown & Latex integration, GraphML export for map layout in yEd)
• adding a simply WYSIWIG map editor

Argdown is still a young software. We think it is stable enough to be used in your work but it definitely needs more testing. If you should encounter any bugs or have ideas how to improve the software, visit the Github repository and post an issue. For general feedback or if you want to contribute to the project, simply write us a mail. We appreciate your help!

The post A new beginning: introducing Argdown appeared first on Argunet.

We post Alexander’s report below:

At the GAP.9 in Osnabrück (conference of the Gesellschaft für Analytische Philosophy) I presented a big argument map using Gregors arguments in his commentary on Decartes Meditationes. It was called “DenkWelt Descartes” and was handmade with YEd to show all arguments unfolded with all premises at once and graphs pointing not at whole arguments but at the premises or conclusions itself. The resulting map (2,5x4m) was added to the poster session of the conference. Some looked at it from distance – taking it more as a piece of art and a representation of philosophical complexities. Some tried to figure out parts of the Meditiationes they knew (especially the cogito-argument and the arguments for the existence of God), asked for a brief introduction into the idea of argument maps or simply wondered if they were meant to read it all.
Both was fine for me, since it was originally made as an exhibit for DenkWelten (www.denkwelten.net), an association of several young German philosophers to found the first museum of philosophical ideas, trying to combine exactly visual work with philosophical ideas. In any case a little help and commentary was needed to get into the map.

Finding a good layout was hard, since automatic layouting couldn’t cope with the text or made the many inferential connections hard to track. So I stuck to the idea to make the graphs as easy to follow as possible. This way “God exists and he is perfect” ended up right in the middle connecting many arguments, what made the argumentative goal of Descartes harder to detect – which might not be what Mr. R.D. (and even Mr. G.B.) originally intended… but what can at least now be discussed fully stretched out on PVC.

The post Mega Argument Map at GAP.09 appeared first on Argunet.

A live reconstruction at the future conference of the German green party.

How can argument maps be used for debate moderation? In this post three short “live reconstruction” case studies from 2007, 2011 and 2014 are presented.

In a “live reconstruction” the arguments of the statements made during a live discussion are reconstructed and visualised in real-time during the event. The most impressive “live reconstruction” technology so far comes from ARG-tech at the University of Dundee. ARG-tech used a huge touchscreen, the “AnalysisWall”, and a large team of analysts to transcribe, segment and analyse an episode of the BBC radio show “The Moral Maze” in 2012.

The technology we have used so far has been much simpler. But the following use cases show that the problems are not so much of technical but of a methodological nature. Even if working perfectly, it is an open question whether the technology is just a nice gimmick or if it produces real benefits for the participants of live discussions. The following cases show that such benefits are difficult to achieve if analysts, moderators, clients and participants have conflicting aims and expectations.

What is a “live reconstruction”?

Our original concept of “live reconstruction” can be characterized in the following way:

• participants argue about a concrete controversial thesis or question.
• three to four analysts work on the reconstruction of the debate with Argunet. Because Argunet is a client-server software they can work on the same map from different computers,
  • inserting important theses,
  • summarizing the arguments in short descriptions and giving them telling titles (there is not enough time for detailed logical reconstruction),
  • sketching the relations between arguments and theses,
  • layouting the argument graph.
• the emerging argument map is projected live on a big screen. Arguments ‘magically’ pop up one by one.
• the moderator uses the resulting map to structure the ongoing debate and to summarize results, e.g. she
  • asks participants whether the reconstruction is adequate,
  • directs attention to arguments that were neglected or to implicit assumptions that were revealed,
  • shows what the central claims are and what dialectical role they play in different arguments,
• participants can refer to specific arguments in the debate in order to
  • express their agreement or disagreement,
  • add new rebuttals or support, or
  • clarify their previously made statements.
• the argument map can be used to document the discussion results.

First case study: Long night of the sciences 2007

2007 was the first time we gave the “live reconstruction” a try at the “Lange Nacht der Wissenschaft” (long night of the sciences) a popular event in Berlin, where universities and other science institutions open up for the general public.

Overall this has been a very positive experience:

• the argument map was a useful moderation tool that made it easier for the moderator to keep an overview,
• participants used the map in their statements to refer to arguments,
• participants collaborated on making the map better and more representative instead of pushing and clinging to their points of view,
• this led to structured, fair and non-confrontative discussion.

At the time we were quite enthusiastic about the prospects of the method. Time has shown that this success depended crucially on the non-typical “ideal” conditions of this use case:

• it was a pro bono experiment, there were no costs to consider,
• the moderator was part of our team and an expert in argumentation theory,
• guests were expecting an experiment and came to learn about the method of argument analysis and reconstruction,
• the topic of the debate was secondary and was decided upon by the audience at the beginning of the experiment.

Second case study: Future Congress of the German Green Party 2011 (Zukunftskongress der Grünen)

Our team at work at the future conference.

In 2011 the German Green Party organized a “Future Congress” as an open and innovative forum for discussions about their party platform. The congress was organized in 14 workshops, some of which were moderated by the party leaders Claudia Roth and Cem Özdemir. We were hired to conduct live reconstructions of two workshops, one on “social justice” and one on a “common European defence policy”. Both workshops were moderated by Cem Özdemir. Our team consisted of one coordinator, two “reconstruction analysts” and one co-moderator. The boundary conditions were challenging, to say the least:

• a huge audience and speakers list,
• limited time,
• the first topic was very broad and there was no clear focus of the discussion,
• many statements from the audience were very emotional and vague,
• the moderator was not an expert in argumentation theory, though we had the opportunity to introduce him to our method beforehand,
• the moderator was a party leader, and had to meet many expectations that were not easily reconcilable with using argument maps to structure the debate and keep the participants focused on specific points,
• because of this and the time restrictions our co-moderator could only play a small and very limited role.

Not all conditions were unfavorable. The Green Party agreed to pay for a team of four experts which is quite extraordinary, considering these were moderation expenses alone. Even with such a large team the reconstruction was very exhausting, stressful and difficult for the team; and it was hard to assess whether the live projection brought any benefits for the discussion, because of the lack of interaction. Though the feedback we got was very positive, we were somewhat disillusioned.

Third case study: Annual convention of the German ethics council 2014

In 2014 we were hired by the German Ethics Council for its annual convention and gave the concept another chance: In a collaboration with Ralph Groetker from explorat we tried to develop ideas to overcome the weaknesses of our concept. We changed the process to make it financially more feasible, decrease the workload for the analysts and increase the benefits of the resulting maps. This process was tested in three parallel workshops on “reproductive ethics”. The changes were the following:

• Due to financial limitations we could only use one analyst per workshop.
• This made it impossible to create a new reconstruction from scratch live; instead we prepared maps beforehand that were based on an online survey of the invited guests and additional research.
• These maps were given to the members of the Ethics Council and their staff beforehand. In several rounds they were revised and enhanced.
• Every guest got a conference binder that included these argument maps; additionally the maps were presented on big posters at the conference.
• These maps were than augmented live with simple comments that described important claims and additional arguments of the participants, without reconstructing the precise relations of these arguments.
• Directly after the workshops the new arguments were added with post-its to the posters.
• Additionally the maps were used to document the results.
• To simplify the process even more we agreed to use the mindmapping software XMind instead of Argunet. Though this made it possible to use icons as mnemonic devices there were some limitations we think speak against using such generic software in the future (for example, the graph has to be hierarchic and argument groups have to be sub-trees).

We think that these changes proved largely sucessful. It made a huge difference for the reconstruction process that the analysts could build on already existing maps. Even though we reduced the team from three analysts to one single analyst, the reconstruction of the new arguments was feasible. The feedback was once again very positive.

Even so, this was a mixed experience, because in two of three workshops the moderators didn’t want to get distracted or restricted by the maps and refused to use live projections. In these workshops the live reconstruction had no influence on the discussion (though it was used for documentation purposes). But maybe this didn’t make such a huge difference, because in all workshops the participants had read our arguments beforehand and we got the impression that some of them used the maps to formulate their statements.

Argument map of the session on “mitochondrial transfer” at the annual convention of the German ethics council. Circular boxes were added live during the event. Rectangular boxes were reconstructed beforehand.

Conclusion:

Live reconstructions can have real benefits if the boundary conditions are just right. But in real-world deployment it is difficult to find and establish these conditions. The most important ones are:

• Preparation: The live reconstruction can only augment an already existing map, so it has to be possible to prepare such a map beforehand.
• Preparation: Clients and moderators have to be included in the reconstruction process as early as possible.
• Moderation: The moderator has to be willing and able to use the map; realistically, this will only be the case if the moderator has been trained in argument reconstruction and analysis.
• Topic: The questions to-be-discussed must be concrete and controversial.

In many cases moderators, clients and participants have conflicting expectations and aims that make it impossible to create these conditions. Under such circumstances further revisions to the process are needed to make argument maps useful for debate moderation.

The post Going live: Using argument maps for debate moderation appeared first on Argunet.

• OLI: A course on argument diagramming by the Open Learning Initiative (OLI) at Carnegie Mellon University.
• CTW: The Critical Thinking Web compiled by Joe Lau and Jonathan Chan, hosted by the Philosophy Department at Hongkong University.
• AUT: The Argument Mapping Tutorials by Austhink.

My upshot: If you’re a newbie to argument analysis and look for a steady, step-by-step introduction, you should start with OLI‘s course and then move to the Criticial Thinking Web for more specific details and thorough treatments. In case you prefer a crisp and astute introduction, you may skip OLI and start directly with browsing the CTW (especially Module A). These two online courses jointly teach you as much as a good critical thinking textbook does. Once you have a firm grip on the topic of argument reconstruction, you might want to check out what Austhink‘s argument mapping tutorials have to say on reconstructing complex debates that consist in many arguments.

Illustrative Reconstructions

Let’s have a look at representative argument reconstructions from the tutorials, which give you a flavour of the different approaches. (My comments are cast against the background of the reconstruction ideal spelled out here.)

OLI’s Argument Diagramming Course

The Argument Diagramming Course discusses a couple of complex arguments, for example the following one:

If the Miranda decision is reversed, police will no longer be compelled to give those warnings; and if they aren’t compelled to give them, they won’t give them. But because police interrogations take place out of public view, the integrity of such interrogations can be safeguarded only if those Miranda warnings are invariably given.

The argument is reconstructed as follows (standard form):

Premise: (1) If the Miranda decision is reversed, then police will no longer be compelled to give Miranda warnings.

Premise: (2) If police aren’t compelled to give Miranda warnings, then police won’t give Miranda warnings.

Implied Sub-conclusion: (C) If the Miranda decision is reversed, then police won’t give Miranda warnings.

Premise: (3) Police interrogations take place out of public view.

Implied Premise: (B) If police interrogations take place out of public view, then the integrity of such interrogations can be safeguarded only if Miranda warnings are invariably given by police.

Sub-conclusion: (4) The integrity of police interrogations can be safeguarded only if Miranda warnings are invariably given by police.

Implied Premise: (D) The integrity of police interrogations should be safeguarded.

Implied Sub-conclusion: (E) Miranda warnings should invariably be given by police.

Main conclusion: (A) The Miranda decision should not be reversed.

And it is visualized as an argument diagram:

Comment: I think that’s nearly perfect. As you can see, the individual inferences are valid and the argument reconstruction hence makes explicit the hidden (“implied”) assumptions of the original reasoning.

Critical Thinking Web

The following text is analysed on the Critical Thinking Web.

We should not inflict unnecessary pain on cows and pigs. After all, we should not inflict unnecessary pain on any animal with consciousness, and cows and pigs are animals with consciousness.

CTW reconstruct the argument as:

(Premise 1) We should not inflict unnecessary pain on any animal with consciousness.

(Premise 2) Cows and pigs are animals with consciousness.

(Conclusion) We should not inflict unnecessary pain on cows and pigs.

Comment: While CTW covers a broad range of topics in logic and argumentation theory that are highly relevant for argument reconstruction, it is, in the same time, a bit poor on (sufficiently complex) examples. — But otherwise the argument reconstructions in CTW, as the one above, are impeccable.

Austhink’s Argument Mapping Tutorials

Now compare how Austhink treats arguments.

The shadows of the astronauts and their equipment in the Apollo pictures seem to point in different directions. This suggests that artificial lighting was used and therefore the pictures were taken in a studio on earth.

This piece is reconstructed as follows.

Comment: Depending on how you spell out the logico-semantic structure of the premisses, the first inference (from middle layer to top conclusion) might be valid, but the second inference clearly isn’t. Many Austhink reconstructions seem to lack the level of precision and explicitness I tend to aim at. (One reason might be that various issues like, e.g., ambiguity can be illustrated with invalid or incomplete reconstructions, too. Nonetheless, the tutorials clearly don’t emphasize explicitness and inferential correctness as much as the OLI course and CTW do.)

How the courses relate to Argunet — and some further remarks

1. Argument map — one word, many things. All courses explain how to create argument diagrams. In the first place, these diagrams visualize the internal (inferential) structure of a single argument. The nodes in these diagrams are statements (and not entire arguments or reasons). So, these argument diagrams translate, in Argunet, into detailed reconstructions you’d compile with the argument editor and represent in standard form (i.e., as a list; more on translating argument diagrams to Argunet here). Accordingly, the argument diagrams are not to bo confused with Argunet argument maps, which contain (primarily) entire arguments as boxes and which visualize the dialectical structure of a debate.This is the reason why Austhink’s recommendation “No Reasoning in Boxes” does not apply to Argunet. (It is however correct that a single premiss in an argument, reconstructed in Argunet, should not contain an inference.)
2. Truth tables. The OLI course and the Critical Thinking Web use the truth table method for checking whether (simple) arguments are deductively valid. That is, I believe, inadequate and risks to lead beginning argument analysts astray. To see this, consider the following argument:
   1. If Peter publishes the original paper even though his student has shown it to be flawed, then Peter is a poor scientist.
   2. Peter’s student has not shown Peter’s paper to be flawed.
   3. Thus: Peter is a poor scientist.

   This is a very bad argument. The conclusion does apparently not follow from the premisses (it can be false while the premisses are true). Now, the argument may be formalized as follows:

   1. If (if P then Q) then R.
   2. Not P.
   3. Thus: R.

   And the truthtable method yields that this inference is deductively valid. So the truthtable method gives wrong results and may lead us astray.

   That’s why I don’t teach truth tables in my argumentation courses anymore.

   (The problem arises, of course, in the formalization of the conditional in premiss (2). If you reconstruct it as a strict implication (in terms of modal logic), for example, the conclusion does not follow anymore and logic gives you the right result, again. However, the problem is that OLI and CTW invite us to use propositional logic and, specifically, truth tables in an uncritical way, and that’s what’s highly problematic.)

3. Rules of thumb. The Austhink tutorial #2 establishes a couple of rules of thumbs for argument reconstruction. These, I think, should be relaxed. Contrary to the Golden Rule, for example, there exist excellent arguments with just one premiss (e.g., arguments that provide a counterexample to a universal statement). Moreover, rather than using rules of thumb for identifying hidden assumption, I strongly recommend to unearth implicit premisses against the background of a validity check (as described by CTW).
4. The macrostructure of debate. What distinguishes the Austhink tutorials from OLI and CTW is that they discuss the macrostructure of a debate reconstruction. This is certainly interesting and valuable. I only find that the pyramid rule cannot be applied to reconstructions created with Argunet (and I doubt it’s a good rule when you work with other argument mapping software). There’s simply no reason to think that the generality of a claim or argument is correlated with its dialectic location in a debate. Arguments that rely on highly general principles can both be raised at the centre as well as at the outskirts of a controversy; very special claims (pieces of evidence, counterexamples) can bear directly on the central thesis or concern outward arguments.

The post Three Online Tutorials on Argument Analysis appeared first on Argunet.

This is how Grötker describes the overall design of the experiment:

“Faktencheck” brings together elements of reader participation and journalistic investigation on controversial issues with a scientific background. There’s a live investigation for a period of 3 days. Readers have the opportunity to join the investigation in a forum. A moderator transfers both comments in the online forum as well as other results from the investigation into a so-called argument map.

According to Grötker, the role of argument maps was ambivalent. On the negative side he notes:

The great hope, which we associated with using argument maps, was that it would be feasible to somehow order the discussion in the forum. In this regard, the experiment was rather disappointing. Only a few commentators made use of the opportunity to refer directly to the branches of the map. At closer look, however, this is hardly surprising: In many contributions, commentators looked for engaging in a dialog — mostly, by the way, in an astonishingly respectful way.

Let me jump in here. It’s clear from a brief look at the webpages which document the experiment that the argument maps didn’t help to structure the online discussions. So, is argument mapping in general unsuitable for such a task? I’m not prepared to draw this conclusion yet. As has been noted by participants of Faktencheck before, it seems a major problem that the argument map is totally disconnected from the online debate.

• The arguments in the map don’t link to the contributions they reconstruct. (Although some arguments contain roll-over quotes from the online discussion.)
• The contributions in the online forum, in turn, don’t link to arguments that represent the contribution, either.
• The argument map is, moreover, embedded on a different page than the online forum.

(To make things worse, the discussion seems to be conducted in several, separate online forums.)

That might explain why the map played virtually no role in structuring the discussion.

Another issue is the software Debattenprofis have used. Look at the startscreen of the map about textile boycotts:

That doesn’t look very inviting. Even more importantly,

• it’s really cumbersome to navigate the map, and difficult to get an overview;
• more specifically, it’s not straightforward to focus on one argument and its adjacent reasons only;
• the debate doesn’t exhibit a macrostructure;
• the hierarchical layout is very space consuming, which is a major disadvantage if the map is embedded.

Let me also note that the Faktencheck argument maps are not based on detailed reconstructions of the arguments advanced in the online forum, but merely “sketch” (as we use to say) the debate. As a consequence, the dialectic relations between the arguments are still provisional and seem to some extent arbitrary.

Ok, back to Grötker’s upshot, which also highlights a positive effect of argument mapping in the Faktencheck experiment:

The visualization fulfills an important function nonetheless. As the argument map strived to represent all pros and cons (concerning the corresponding claim), it goes along with a certain promise of neutrality. The opponents don’t have to agree on a common evaluation of the arguments in the map. But they have to agree that the controversial issues are comprehensively represented. This promise of neutrality was particularly helpful when we asked external experts to join the factcheck. The opinions of experts could enter the map without us being required to come to the same conclusion as the experts in our final summary — a fair set-up for all parties.

It’s an obvious virtue of argument mapping that it allows opponents at least to agree on what the arguments are and how they relate to each other. Also, to agree on an argument map doesn’t compel one to endorse a certain position. Faktencheck seems to have vindicated these argument mapping advantages.

To connect the dots, however, imagine an argument map browser that allows users to enter their assessment of the arguments (‘refute’ vs. ‘accept’) as they skim through the debate. This might not only enhance user experience but help to integrate the debate visualization and the online discussion.

Be that as it may, Ralf Grötker has conducted an exciting experiment and I’m looking forward to Debattenprofis’ future argument mapping projects!

The post Factcheck by Debattenprofis: A Comment on an Argument Mapping Experiment appeared first on Argunet.