Previous Topic Next Topic
classic Classic list List threaded Threaded
1 message Options
Reply | Threaded
Open this post in threaded view


Jeffrey Sarnoff
We have been discussing `protocols` as a means for safely structuring
facilitated computational interactions and as requirements management.   

Here is another use for this technology, a meetable purpose.  
For a `protocol` to communicate aor enforce the way a given  
computational facility is to be approached and utilized,  
it must be that the `protocol` provides as a standard of
comportment, the manner with which it self-presents.
I specifying right use, a `protocol` also conveys some
information about the nature of that computational facility.

I would like to use both aspects of the protocolean nature.
We need a good and well-fitting way to let others know
of our high-level exports and their intrinsic beauty.
We need a good and well-fitting way to let others know
what they are expected to bring to the use of this, 
that same computational facility.

If your five dimensional fractal density solver performs
arithmetic on my five-continent coastline data, that is
unsurprising and I do not need a special telephone call
to tell me that there will be some addition going on.
Do ring to let me know should your solver rely on
the precision and accuracy of my data.

If you need to call `precision( vectorOfCoastlineData )`
and I have not allowed the type of my data to become
elaborated with a reflective gleaner of self-precision,
our playdate ends quickly -- long before tea?tee time.

The use case that motivates this thought is that some
(much, most) Julia code that performs numerical ops
and applies mathematical transforms to someone else's
numbers and numeric data hard encodes unhelpful and
many times unneeded constraints and limitations that
preclude smooth working with new numerical types.

If I need to know that your package works correctly
only if my data is monotonic, you need to know to
inform me that you call frexp() on each datum
to apply trailing_zeros() to the significands.
This lets me provide within my numerical type
an implementation of fexp() and trailing_zeros()
which is appropriate to specifics of my numbers.

That is how protocols bring our work today 
to tomorrow's them and it all just works.