Re: In precision typing we trust

[Alex // nytpu <nytpu@example.invalid>]

On 8/27/25 6:33 PM, Lawrence D’Oliveiro wrote:
> On Thu, 28 Aug 2025 00:20:38 -0000 (UTC), Kevin Chadwick wrote:
> 
>>> Ada is the best language by far for mapping registers to hardware
>>> or data packets via representation clauses. I have found many bugs
>>> in STs svd files and C code because of Adas type system.
>>
>> The reason it's so good aside from Gnats excellent size checks etc.
>> is due to precision types :-)
> 
> But can you do type checking dynamically, at run-time?
> 
> For example, in one project (a Python wrapper for receiving fanotify
> events from the Linux kernel), I had to deal with a sequence of
> packets of variable length and type. I could dispatch on the
> packet-type field and return correspondingly typesafe results in my
> wrapper.
Yes, that's sorta the entire premise of Ada's OOP lol.  Use the `'Class` 
type to give you a root class and then you can dispatch with a method 
call or you sorta can match directly (nowhere even near the convenience 
of more modern functional-style matching admittedly though).  Or just 
have a variant record that you can match on with a `case` if one 
prefers---I usually do this unless I need dynamic dispatch or inheritance.

To be clear, for nearly all of this thread I've strongly agreed with you 
(mostly seems like Dmitry is just being willfully ignorant about basic 
computer science facts like "what dynamic typing is and how it's 
orthogonal to strong/weak typing").  But in the specific case of 
interacting directly with hardware[1], Ada is far and away the best 
language in existence for it.  And I'm a weird-ass language connoisseur 
and like doing weird-ass things with them, so I have lots of experience 
with everything all over the map.  Ada 2012, with its representation 
clauses and useful set of aspects, is really just the best for working 
with memory-mapped I/O and such.

~nytpu

[1]: as in, directly interacting with it in an embedded context; not 
using an OS abstraction, not binding to an existing C HLL, etc., 
specifically writing the bindings yourself.  If you're dealing with 
existing software abstractions it's much more up in the air and comes 
mostly down to personal preference (I'm partial to Common Lisp when in 
hosted environments myself, but in this case I assume the benefits are 
mostly equivalent to Python other than Lisp's macro stuff)

-- 
Alex // nytpu
https://nytpu.com/ - gemini://nytpu.com/ - gopher://nytpu.com/