All of the storage types involve storing something at one point and retrieving it later. To do this in only one operation, you should do either storing or retrieving automatically, and specify the position of the stored value in the other operation.
That is, for explicit storage, you could create an operator to retrieve the nth calculated value before this operation, or put back the current value after n operations. Alternatively, you could use the absolute position from the start of the program, or do more things such as removing some elements automatically after some operations (like in a stack). You could also make multiple operators, retrieving from different copies of the storage with or without these automatic operations. And you should try to make the maximum number needed to specify in the operations reasonably small, so you could assign one operator for each number.
But in most cases, you don't even need an operator and the language will do this implicitly. That is when you need to consider a more standardized model such as stacks or queues. The most successful for now seemed to be tacit programming, which doesn't even mention storage directly.
If you want to design a new such model, you could try expanding the evaluations as a dag, and try to think of a default dag if nothing else is specified. Most likely, the default is just a tree, except for that multiple leaves may be linked to the same input. You could for example use a queue for a balanced tree, or a stack for a deep tree where leaves are mostly constant, or something like Jelly for a deep tree where leaves are mostly copies of the input.
But note that, you could encode the shape of a binary tree in only 2 bits per operator. So, if your language has less than 64 operators, you may actually ignore the traditional models and just encode the complete tree in the spare bits (call them combine_parent and below_leaf flags). Even if there are more operators, you could make a fairly good default (such as the model of Jelly) and 3 modifiers to change it.
You could use the same model for implicit and explicit storage for convenience, but you don't have to. For example, you could use a stack for implicit storage, but don't pop elements in the explicit storage (or in another explicit storage in addition to the implicit one). It's likely it won't be called a stack in the final documentation, but you get the idea.
For reference, the size of the perfect encoding of a binary tree is the logarithm of the Catalan numbers. And the size of the perfect encoding of a "binary" dag is the logarithm of A082161, but obviously impractical. This assumes an operator with different argument order two different operators, adding another bit when it is not.
Sometimes you may still want variables for the loops. It might be possible to rewrite the loops in other ways. But if you really need it, don't use a 1-byte construct in addition to a name to define the variable. unless you are only using the preinitialized values, it's usually more efficient to use a 1-bit flag to specify whether you are reading or writing this variable.
1I think you should include a definition of these terms in your question – user41805 – 2017-04-29T17:41:51.277
How should the answers be? One tip per answer, or one generalised community-wiki answer for all the tips? – user41805 – 2017-04-29T17:44:14.923
IMHO implicit input belongs in a different question, since it's basically going to be the same no matter which storage method you use. – ETHproductions – 2017-04-29T17:49:24.860
This question is entirely dependent on what kind of language you're making. Too broad. – Fatalize – 2017-04-29T17:55:17.957
2@Fatalize Technically the storage method isn't dependent on what kind of golfing language you're making, the kind of golfing language is dependent on the storage method... – ETHproductions – 2017-04-29T17:56:29.273
1@ETHproductions They're totally interdependent. – Fatalize – 2017-04-29T18:00:27.427
I agree with @Fatalize, this is too broad. Even though I answered, I unfortunately can't make your golfing language for you. – NoOneIsHere – 2017-04-29T18:08:21.997
@Fatalize you say that "This question is entirely dependent on what kind of language you're making", but you also say "They're totally interdependent.". I don't understand. – programmer5000 – 2017-04-29T18:09:33.370
1I added some rough definitions of the various storage terms, feel free to edit or roll back if you don't like them. – ETHproductions – 2017-04-29T18:10:16.263
@ETHproductions thanks, those are great! – programmer5000 – 2017-04-29T18:10:58.933
2There is a very close relationship between the storage method and the type of language, but I think you have to look at both. For example, "imperative" languages (those which perform their instructions strictly left-to-right) can be stack-based (CJam, 05AB1E), tape-based (BrainF***), or something else entirely (V, which uses one big 2D string called the "buffer", along with a few registers). There's also prefix-based languages (Pyth), infix-based languages (Japt, Pip, and basically every mainstream lang), link-based languages (Jelly), etc. all of which hardly use any of the mentioned methods. – ETHproductions – 2017-04-29T18:14:50.990
@programmer5000 It's much better now, but it's still a bit broad. If you say, for example, "I would like to know the advantages and disadvantages of each", or something like that, then this would not be too broad. I don't want to put words in your mouth though, so I won't edit. – NoOneIsHere – 2017-04-29T18:15:14.820
1@programmer5000 Great, I will retract my close vote. – NoOneIsHere – 2017-04-29T18:17:30.890
This question is about starting to design a golfing language. When you're starting to design a golfing language, you pretty much have to decide on the best types of storage to use and the type of data flow through the code (e.g. left-to-right for CJam, BF, etc., right-to-left for prefix langs such as Pyth, a combination of both for langs such as Jelly...) at the same time because these two things are very closely related. Because of this, would you mind editing the question to include choosing the type of language? I can edit for you if you'd like. – ETHproductions – 2017-04-30T00:18:52.347
1Golfing languages are about reducing redundancy - being able to express a solution in terms of its logical components with as little boilerplate as possible. You should try to make as many things implicit as you can. Most likely, use of the queue would be implicit. Tapes tend to complicate things, and I can't see how they would be useful if you already have a stack, reqisters, etc as well as a good selection of data types and builtins on those data types. – Esolanging Fruit – 2017-05-01T09:10:10.250