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!

Leave a Reply

XHTML: You can use these tags: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>