From: arne@vajhoej.dk   
      
   On 4/8/2025 1:27 PM, Simon Clubley wrote:   
   > On 2025-04-08, Arne Vajhøj  wrote:   
   >> On 4/8/2025 8:20 AM, Simon Clubley wrote:   
   >>> On 2025-04-06, Arne Vajhøj  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   
      
   --- SoupGate-DOS v1.05   
    * Origin: you cannot sedate... all the things you hate (1:229/2)