Re: New aggregates with Ada 2022.

["Randy Brukardt" <randy@rrsoftware.com>]

"Dmitry A. Kazakov" <mailbox@dmitry-kazakov.de> wrote in message 
news:t96i9f$1mc1$1@gioia.aioe.org...
> On 2022-06-25 05:13, Randy Brukardt wrote:
...
>> I don't think programming abstractly and translating that into good code
>> will ever be a bad idea. After all, that is the idea behind Ada. If you
>> truly want to worry about the cost of compilation, then you have program 
>> in
>> a very close to the metal language, even lower level than C. And current
>> machines are way harder to generate code for than the Z-80 that we 
>> started
>> out on (and even then, we generated pretty bad code with the very tiny
>> compiler).
>
> No, I worry about cost of execution. You want to simplify the compiler at 
> the expense of the program complexity and efficiency of its code.

I think we strongly agree here. I want to simplify the front-end to 
strengthen abstractions, and so that the effort can be put where it belongs, 
on static analysis/optimization and on code generation. These things are 
mostly fancy pattern matching, and the more of it that you can do, the 
better. Time spent implementing features that don't increase the expressive 
power (or worse, compilicate code generation in all cases) is 
counter-productive.

>> I'd rather plan for a future where the compiler tool set does a lot of
>> correctness checking for one's programs;
>
> Yes and correctness checking requires proper and very refined abstractions 
> you are ready to throw away. Here is a contradiction. In a language like 
> Forth there is basically nothing to check.

Slices are not an abstraction. They are a way to describe a particular kind 
of processor operation in a vaguely abstract way. But they don't extend to 
user-defined structures or even multi-dimensional maps (arrays if you 
prefer) in any practical way. The distributed overhead that they cause is 
immense (for instance, you can't have a discontigious array represesentation 
with slices, unless you are willing to pay a substantial cost for *every* 
array parameter). They're the anti-abstraction feature.

                                         Randy.