A new beginning: introducing Argdown

By now, Argunet belongs to the senior citizens of the software realm. While it has grown quiet around this blog, behind the scenes, we were busy experimenting with a different technological approach to argument mapping. The result is a completely new software tool that we are very excited about. This post introduces Argdown to the Argunet community and explains why it has become our new tool of choice.

 

argdown-sandbox-soft-drugs-1
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-mark-blue-256x256

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

argdown-vscode-semmelweis-1
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.
argdown-sandbox-greenspan-1
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!


Going live: Using argument maps for debate moderation

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. These cases show that the challenges of the approach are not so much of a technical but of a methodological nature. Even if the technology works perfectly it is difficult to get the conditions right so that the “live reconstruction” is more than just a nice gimmick.

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

Continue reading…


Relaunch & Release: Argunet 2.0

It’s been a while since our last update to our site or software. So let’s do both at once. Let me introduce you first to our new site and then to the new version of Argunet Editor.

Relaunch

We decided to simplify things: one page for the editor, one for our upcoming browser widget and one for our new blog. This will make it easier for you to find what you are looking for. And it will make it easier for us to maintain the site. Did I say “new blog”?

Yes, a brand-new blog!

While we were busy deploying Argunet in exciting new projects and trying out unreleased cool features, this site lay dormant for years. With this new blog we want to change that. Next week we will begin to post regularly about everything related to Argunet, argument maps and argumentation theory in general. So watch out for new posts!
Continue reading…


So, what exactly is an argument map?

This is a quick introduction into argument maps: How to create them, how to read them and what you can expect to get out of it.

An Argunet argument map visualises the structure of complex argumentations and debates as a graphical network. In this network all nodes are either sentences or arguments and all relations between them are either attack or support relations.

The reconstruction and visualisation with argument maps can be useful in many ways:

  • Argument maps can give you a fast overview over the state of a debate
  • Argument maps help you to remember complex argumentation structures
  • The logical reconstruction allows a detailed analysis and evaluation of arguments and dialectic strategies
  • Argument maps help to keep focused on relevant parts of the debate by filtering out irrelevant or redundant information
  • Argument maps help concentrate on a rational, fair debate
  • Argument maps can guide and structure live discussions. Misunderstandings, repitition and unfair persuasion techniques can be avoided.
  • Argument mapping can be used for presentations or whole seminars

Continue reading…


Argunet Server up again

The Argunet Server is up again. We hope that it will work more reliable now. If you have any problems, please write a note at our mailing list.


Argunet server temporarily down

The Argunet Server at the FU Berlin is temporarily down for maintenance and updates. It will be back soon. No data or debate is lost, so please be patient.

Until then, you can use all features of Argunet locally and offline. If the server is running again, you will be able to upload your argument maps to an online debate. Sorry for the inconvenience.


Out of Beta: Argunet 1.0.0 released!

After more than a year of work, we proudly present you Argunet 1.0.0! By now Argunet contains every feature you need for rapid and in-depth argument mapping. Thanks to all who participated in this project, especially to our lead developer David Schneider, who spent quite a few weekends working with us on Argunet long after his actual work had been done.

With this release the Argunet development has not come to an end. We already have many ideas for new features, a new task list and even some money for development. Parallel to this, we work on our new homepage, so expect to see something new here very soon…
Continue reading…


Argunet wins FU e-Learning Award

Argunet has been awarded the e-Learning price of Free University Berlin (FU). It has been nominated in the category “Didactics”. The Center for Digital System at Free University Berlin distinguishes three outstanding e-Learning projects each year.


Argunet employed in Organic Computing Project

Argunet is part of an interdisciplinary project funded by the German Federal Ministry of Education and Research which aims at assessing the benefits and risks of organic computing. The project is coordinated by the Institute for Ecological Economy Research. Argunet will be used to map the arguments for or against developing and applying organic computing technology.


Argunet Release 0.9.0 Beta

In the last two months we have focused on getting things done. Instead of wasting time with buggy releases, we have skipped some version numbers and have now reached a state that deserves to be called 0.9.0! This is the last beta version of Argunet. Nearly all features for 1.0 are implemented and the bug list is reduced to a few harmless creatures. We can now work exclusively on making Argunet as stable as possible

The server has also been updated and is now incompatible with older versions of Argunet. If you want to work online, please update your client!

Features:

  • Argument editor undo/redo: As long as you edit your argument, you can always undo and redo your last changes. This feature is restricted to the argument editor, because of the optionally distributed structure of Argunet. You cannot undo changes, that possibly are already used by other users, to avoid confusion and errors.
  • Recently used debates: Open your recently used debates directly from the “File” menu.
  • New alignment tools
  • Delete debates
  • Interface optimization: We have optimized Argunet’s usability in many respects.

Fixes:

  • Nearly all serious known bugs (for exceptions see below). :)

Known Issues

  • On OSX it is currently not possible to create new debates locally. We have already identified the cause and will fix this in the next days.
  • In some cases, it is not possible to save edited arguments. This is our last serious bug and we will try to chase it down in the next days.