On Friday, 10 October 2014 at 21:54:32 UTC, Peter Alexander wrote:
On Friday, 10 October 2014 at 21:11:20 UTC, Ola Fosheim Grostad
wrote:
On Friday, 10 October 2014 at 09:00:17 UTC, Peter Alexander
wrote:
You can't have simple, expressive, and low level control.
Why not?
It's just something I believe from experience.
Ok, beliefs are good, but one should not limit visions by them.
The gist of my reasoning is that to get low level control you
need to specify things. When those things are local and
isolated, all is good, but often the things you specify bleed
across interfaces and affect either all the implementations
(making things more complex) or all the users (making things
less expressive).
I don't think there is anything that prevents a language from:
1. Allow the user to specify the constraints and let the system
fill in the details.
2. Let the user guide the search down to the low level details
for efficiency.
So, from a theoretical point of view I'd say it should be
possible to go from high to low level with a reasonable simple
language at the cost of an advanced compiler.
If you can specify how a program should work and let a human
being construct a program from it that works from the
specification alone, then a "competent" compiler/expert system
should be able to do the same thing.
For example, consider the current memory allocation/management
debate. I cannot think of a possible way to handle this that
simultaneously:
(a) gives users full control over how every function
allocates/manages memory (control).
(b) makes the implementation of those functions easy (simple).
(c) makes it easy to compose functions with different
management policies (expressive).
I think the compiler should handle memory management and let the
user configure the compiler.
It is rather obvious that the compiler sometimes should to
instantiate two different versions of the same function based on
usage on the call site, so if you don't let the compiler handle
this then achieving the optimization potential becomes difficult.
Another point: compiling code to run on allocated activation
records is not the same as having it compile for a call-stack. If
you want lots of fibers you have to give up the concept of a
stack and stick to activation records. It is also a more generic
concept (Simula used it to represent both objects and memory
function blocks, they had the same internal representation).
Maybe there's a way to do it, but if there is I imagine that
language and programming experience is going to be vastly
different from what we have now (in any language).
Probably. So if you are going to support low level programming
then it is better to focus on the low level and be a bit more
reluctant to add high level features.
From a system level language I don't really need:
- templates
- exceptions
- fibers
- garbage collection
I'd rather have basic building blocks and some kind of well
designed deductive capability. Type systems are deductive in
nature, so I think deductive compile time evaluation makes sense.
