Many people who are new to argument mapping look for a convenient software tool. Similarly, instructors in critical thinking or informal logic would often like to point their beginner students to a suitable tool for basic argument diagramming. Ideally that tool would:
- Be free
- Be easy to use
- Be good enough for simple maps
- Not require installation
- Not require a specific operating system (Windows, Mac) or browser
- Not require creating an account on (yet another) website
- Integrate seamlessly with other tools already being used
- Be free (yeah, this seems to keep coming up)
After much searching around over the years, my current view is that the tool best meeting these conditions is Microsoft SmartArt. Nearly everyone already has, or has access to, Word and PowerPoint, and many use them almost everyday. Most would be surprised to know that they have built in a passable facility for quickly creating simple argument maps.
Of course I’d known about SmartArt, and the possibility of using it for argument mapping, for years. However for most of that time I’d written it off as being superficially attractive but too limited and frustrating to use. Recently I’ve changed my tune. As described below, if you pick the right template and persevere a little bit, you’ll find that SmartArt can do a reasonable job. It is certainly not ideal, but it may be the best – or rather, the least bad – option currently available.
If you’re not familiar with SmartArt there are introductory videos on Youtube, such as this one.
In what follows I’ll assume that argument maps are (basically; see below) hierarchies or tree structures. This is convenient because all SmartArt templates are based on hierarchies, represented in editing mode as indented lists. Some of the SmartArt templates are explicitly classified as “Hierarchy”:
The templates I find work best are Labeled Hierarchy and Table Hierarchy. (Tip: don’t bother with the one called Hierachy.)
Here’s a very simple argument map in Labeled Hierarchy format:
This is using the default colour scheme. A little adjusting using the usual formatting commands results in a map with a more standard colouring:
This template has a few drawbacks. For example, the lines joining the arguments to the contention really should be separate arrows. Overall, however, it is a pretty classy diagram, and it only takes a minute or two to create.
A neat feature of SmartArt is you can easily change the template while keeping the content the same. Here’s the same map (minus the labels) in Table Hierarchy format:
I’ve included in this image the editing panel at left. This is only visible when the SmartArt graphic is selected.
As you’d expect, arguments can be nested indefinitely deeply:
The SmartArt algorithm is “space filling” so that no matter how many nodes there are in the argument, the map will fit into whatever space you specify for the SmartArt graphic. The SmartArt graphic can be resized by simple dragging operations. If you want to create a really complex map, you can set a large custom size for your Word page or your PowerPoint slide, and add as many boxes as you like.
Any experienced argument mapper reading this will no doubt be thinking something like:
Fine, but what about multi-premise arguments (a.k.a. linked arguments)?
The reality is that hierarchical argument maps are not actually simple tree structures. The technical name for the kind of structure that argument maps have is hi-tree; see this paper for explanation, and a description of layout algorithms for hi-trees. SmartArt is based on simple tree structures, and so in principle cannot properly represent reasoning. However the Table Hierarchy format allows a pretty good approximation:
Note the nested linked arguments.
To create the bar which binds premises into a linked argument, you just create an empty node in the hierarchy, and resize and recolour it appropriately.
In theory, there’s no limit to how complex Table Hierarchy maps could get. In practice, the map above is towards the upper limit for SmartArt argument maps. The biggest problem you start to encounter is that modifying the map structure starts to become a challenging exercise in hierarchical puzzle-solving. You can’t just drag and drop objects to add to, or modify, a map; all editing of structure is done in the left hand panel (see graphic above) as operations on an indented list. This is easy in simple cases but becomes frustrating and time-consuming in more complex maps.
Even in simple cases, using SmartArt to create argument diagrams takes a certain amount of familiarity with SmartArt manipulation and Word formatting more generally. I haven’t tried to cover these topics in this post. If you’re an instructor recommending SmartArt as a diagramming tool, you’d probably want to have/get that familiarity yourself and then give your students some guidance. Guidelines might include:
- Use the right template (NOT the one called “Hierarchy”)
- Specify font size across the whole graphic to specific size rather than allowing the algorithm to set font sizes
- When needed, resize the whole graphic so text fits nicely in boxes
These are very simple operations to carry out when you’re familiar with them.
Also you probably should provide students with semi-prepared graphics for them to use as starting points.
For more advanced users…
For anyone who wants to get more serious about argument mapping, but still wants
- To stay within the Word environment; and
- Something free
there is the CASE-mapping Word Add-in we created to support a specific variety of argument mapping:
It comes with an instruction manual, but the support material that is currently publicly available is quite limited, so you need to have a pretty good idea what you’re doing to find this useful.