Re: Clair Grant on VMS code base

On 4/8/2025 1:27 PM, Simon Clubley wrote:

On 2025-04-08, Arne Vajhøj <arne@vajhoej.dk> wrote:

On 4/8/2025 8:20 AM, Simon Clubley wrote:

On 2025-04-06, Arne Vajhøj <arne@vajhoej.dk> wrote:

On 4/4/2025 2:00 PM, Simon Clubley wrote:

The problem with that analysis is what DCL does.
>
It basically parses, validates, and executes commands it has been given.
That is something which can be implemented a lot more easily and concisely
in a HLL with abstracted data structure capabilities (which includes
even C) than an assembly language with no such capabilities.

>
It is not obvious to me that:
>
(LOC/FP for Macro-32) / (LOC/FP for C)
>
is a lot higher for a shell than for the average application - data
structures are not anything special for shells.
>
But maybe.

>
It's a lot more complicated than that.
>
For example, take a LL(1) RD parser. Even ignoring the processing
of the results from the parser, how much code (and how much effort)
do you think it would take to implement it in Macro-32 compared to C ?

>
Still not obvious to me that it would not follow normal LOC/FP
ratios.

 Try implementing one, especially with a reasonably sized grammar, and
you will very rapidly understand that it is not as simple as you seem
to think it is. :-)

I have not made any claim about it being simple.
I have made a claim that the ratio for LOC/FP for Macro-32
and LOC/FP for C for such a problem would not be significantly
different from other application types.

Effort is a different issue. If someone said:
>
x1.6 LOC
x16 hours for initial write of code
x160 hours for maintenance of code
>
then I would consider it likely.
>
It has been hinted a few time that the DCL code is not easy to
understand and modify.
>

 As I mentioned above, this is no longer about DCL. I picked the above
standalone example, a LL(1) RD parser, because it's a really good example
of the different scale of effort involved in writing it in Macro-32
instead of in C.

I have not made any claim about effort either.
Are you sure that you have understood the topic??
The classic assumptions are:
LOC = a * FP
effort = b * LOC**c = a * b * FP**c
where a, b and c are language specific and c > 1.
The topic is whether the first one is true (strictly speaking
it does not need to be linear for my original claim to be
true - it would be true for any LOC = a * f(FP) where f
does not depend on language).
Whether a[Macro-32] * b[Macro-32] * FP**c[Macro-32] is at a different
scale than a[C] * b[C] * FP**c[C] does not say anything about that.
Arne