Do you know the operator precedence rules in the programming languages that you use? Given an expression like this one in Java:

x/6+5&8>>2-4!=8

Can you say how it will be parsed? (Never mind that the semantics may be meaningless; the parser doesn’t care about semantics.) Generally, programming environments give very little help in improving readability of expressions; the expression will be displayed exactly as above. You do get bracket-match highlighting if you have brackets (and some would argue that you should always bracket expressions for extra clarity). But maybe the display of expressions can be further improved in other ways.

Designers tend to use whitespace for grouping items — for example, grouping related columns in tables. And in fact, a lot of programmers do tend to omit the whitespace around high precedence (tightly bound) operators while putting it in around lower precedence operators. You are much more likely to see this:

dist * Math.sqrt(x*x + y*y)

Than this equally spaced version:

dist * Math . sqrt (x * x + y * y)

Or this devilishy spaced version:

dist*Math . sqrt(x * x+y * y)

If the rule that most people follow is simply to have whitespace inversely proportional to the precedence of the operator, surely we could automate this in a programming editor.

### Dynamically varying whitespace

Consider this expression, without spaces:

Using the parse tree of this expression, we can assign smaller whitespace to operators nearer the leaves (higher precedence operators which bind more tightly) than operators nearer the root (lower precedence operators):

It is now more obvious at a glance how the expression should be read, compared to the unspaced original. Not only is the display clearer, but if the editor takes charge of putting the whitespace in expressions, the user can save keystrokes by never having to insert spaces in expressions in the first place. They can enter the unspaced version above, and the editor displays it as the second version automatically.

### Choosing the amount of space

One design question is whether the width of whitespace is solely determined by absolute operator precedence — i.e. plus always has the same amount of whitespace around it — or whether it is determined by the relative precedence of the operator in the chosen expression. In the absolute case, the complete expression “2 * 3” will be spaced differently to “2 + 3”, which to me seems odd. In the dynamic case, you get spacing readjustment: if you take “2+3” and add “*4” on the end, the + will get more space added to reflect that its dynamic precedence has changed. That is:

Becomes:

While re-spacing as you edit is visually disturbing, I think this is the right thing to do — the addition of *4 has changed the semantics of the existing expression (it is not “(2+3)*4” but rather “2+(3*4)”) so respacing it to reflect the altered semantics seems correct.

### Longer expressions

There is a limit to how long an expression this technique can make readable — our earlier terrible expression:

Becomes a bit better when space is varied:

But I think in that case, there’s only so much that spacing can do — you really should add some brackets.

### Summary

I’ve discussed a way that programming editors could be smarter about whitespace when displaying expressions: dynamically varying the whitespace around operators based on their relative precedence in the expression. This is likely to be included in a new editor we’re currently working on for our Greenfoot system. I note that this scheme does vary the width of spaces in your editor, which may upset some users. But while fixed-width spacing is useful for aligning the left-hand edges of lines of code, I’m less convinced that it matters within the line of code.

Addendum: a colleague points me to this work which mentions a similar system for mathematical equations (page 6). It’s interesting that this idea has been implemented in mathematics but not yet caught on in programming.

Hi Neil,

Very interesting ideas! There might also be possibilities for temporarily changing the layout or rendering of expressions (in the expression itself or perhaps in a tooltip etc) – e.g. adding spacing, or adding parentheses, in response to a key combination or mouseover. You could then use very strong visual indications when concentrating on a single expression, without cluttering the normal rendering of the code?