Question: [Underload](http://esolangs.org/wiki/Underload) is a stack-based semi-functional tarpit created by [ais523](https://codegolf.stackexchange.com/users/62131/ais523). I've recently been trying to golf in it, as it's a surprisingly elegant language.

What tips do you have for golfing in Underload? (One tip per answer)

Answer: 
Use `*` for output
------------------

Because [you can output by leaving a string on the stack](https://codegolf.meta.stackexchange.com/a/8507/61384), it might be useful to accumulate the string by using `*` rather than outputting with `S`. Say your challenge was "take a string and append a space", the way to do it with output would be:

```
S( )S

```

The way to do it with `*`, on the other hand is one byte shorter:

```
( )*

```

The problem is that if your output has a lot of accumulation, it might cost bytes to deal with the output element on the stack.
Put Unneeded Stack Values into the Program Space
================================================

Underload actually has two stacks—the stack of strings, and the stack of commands that make up the source code. Underload's `^` instruction lets us move strings from the former stack to the latter. By doing this, we can save a lot of unnecessary stack manipulation.

For example, say we have `(a)(b)(c)` on the main stack and we'd like to concatenate the bottom two elements, ignoring `(c)`, to get `(ab)(c)`. The naïve way to do this is to rotate the stack to get `(c)(a)(b)` and then concantenate and swap back:

```
a~a~*~a*^*~

```

This is bad. Using `a~a~*~a*^` to rotate the stack like this is extremely costly, and should be avoided when possible. By putting `(c)` into the program space instead, this can be made four bytes shorter:

```
a(*)~*^

```

The idea is to take the instructions you'd like to execute and then add an instruction to push `(c)` back at the end, and then evaluate the result. This means that we don't have to worry about `(c)` until it's pushed back after we've finished.