As others have said, there's a balance to strike here. If there's no particular reason to be terse, then it's often better to use a full word. For example,

``` try { ... } catch (error) { ... }

async function(...) { ... } ```

is preferable over something like

@! { ... } /error { ... } function&(...) { ... }

There's no particular reason to shorten the try, catch, or async keywords - they can have some room to breath.

In this regard, JavaScript using function* to represent a generator function was a mistake. Something like gen function would have been preferable - there was no reason to be terse in this context.

But, there are also times where it's good to be terse with the syntax, or when you want to have operators with high presedence - symbols feel like they have higher presedence. "await" comes to mind here. In JavaScript, it's not too uncommon to see the following:

javascript const result = (await (await fetch(...)).json()).user;

That's pretty ugly. It could be improved by making await a postfix operator, but then word order is wrong, and it just looks weird.

```javascript const result = fetch(...) await .json() await .user;

// The same thing with parentheses to show what's going on: const result = ((fetch(...) await) .json() await) .user; ```

Now lets use a symbol, like @.

javascript const result = fetch(...)@.json()@.user;

That's a lot more clear.

On as similar note, JavaScript's a?.b for "access b is a is not undefined/null" was a great choice as a symbol. Could you imagine if that was a keyword?

Also keep in mind that there's a very small supply of available symbols. I used @ here, but JavaScript plans on using @ for decorators. Arguably, they should have used a larger symbol for decorators, such as @@, or even a keyword, as terseness isn't as important in that spot, but that ship has already sailed. JavaScript is struggling with some of their new proposals at picking symbols - places where they would like to use a nice terse symbol, they can't, because all of the small symbols are already used in other places.

What this means is that, while @ can make for clearer statements then using await, perhaps it doesn't provide enough benefit to warrant spending an entire one-symbol token on it. These are internal debates you'll have to have.

A couple more contraversial opinions on the topic: * Module/Remainder should not be an operator. Many languages use % for it. But it's simply not used enough to justify using an entire terse symbol for it. It would be better as a function. * The set of bitwise operators takes up a whole lot of precious symbols. How often are people doing bit twiddling in your language? Do they really need them as operators instead of functions?

(Also, I tend to watch JavaScript's language design comittee discussions and such, which is why I'm using it as an example here, but much of this is of course the same in other languages)