In a language like C/D1 there are common simple parts that's easy to remember,
like:
int x = 10;
Other parts are more complex, but they are common enough that you usually
remember them:
for (int x = 10; x < foo.bar(); x += 2) {}
Other parts of the language or its standard library are less easy to remember,
but in normal programs they are uncommon enough that looking them into the docs
is acceptable. You don't need to keep in memory all the standard library of
Java or C# to use such languages.
But in a language (like D1/D2) there can be parts that are both common enough
and hard enough to remember, those are a problem, because looking in the docs
each time is a waste of programming time (especially if you don't have an IDE
under your hands) and more. Realistically it may be impossible to remove or
simplify all such parts from a large system language as D1/D2, but it's
important to write down a list of such parts, to keep such list in memory
during the language design, and to try to minimize the length of such list. In
theory some of the things in such list can be modified to make them more easy
to remember, etc.
It's nice to program in Python also because most common parts of the language
are easy to remember, for example the are't one undred string/list methods as
in Ruby, so after few months you memorize the most common Python string
methods, and this helps speed up programming significantly.
What are the parts of the D1/D2 languages that are both common enough in
programs and not easy to remember, so you need to look them often in the docs
(or in an example list, code snippets list, already written code, etc)? This
list is partially subjective, but probably there are also some common trends.
For example the syntax of opApply is one of the things I have often to look up
in the docs (while I never need the manual to remember how to write a generator
in Python, that has very similar purposes).
Do you have other parts to add to this list?
Bye,
bearophile
