OSNews

Okay, so it is at the same point as my approach. More generally, I have been for some time under the impression that in this topic, we are talking about very similar things with a very similar set of advantages and drawbacks even though we don't know it yet.


*laughs* Do you want to know the most ugly hack ever usable to do this in my "RPC" system ? Have the server process broadcast a prototype that is associated with the NULL function pointer. Any attempt to run this prototype during the design phase would crash the server, but if you make sure that the functionality gets implemented...

More seriously, common development practices like using placeholder implementations of the "myfunc() { return 0; }" kind can also be envisioned. As usual, the trick is to always remember to implement the functionality in the end.


I broadcast a version number ALONG WITH a prototype, doesn't the whole thing qualify as a spec sheet ?

Besides, removing functionality can be done, here's how :

BEFORE:
-Server process provides functionality A and B
-Client process shows up, asks the kernel for access to the functionality A of server process during initialization
-The kernel check that server process indeed broadcasts functionality A, and says client that everything is okay
-Client can later make calls to A

AFTER:
-Server process only provides functionality A now
-Client process shows up, asks the kernel for access to the functionality A of server process during initialization
-The kernel check that server process indeed broadcasts functionality A, and says client that everything is okay
-Client can later make calls to A

About interoperability between versions, I thought about using semantic version numbers of the Breaking.Compatible form.

Edited 2011-05-31 07:47 UTC

Neolander,

"About interoperability between versions, I thought about using semantic version numbers of the Breaking.Compatible form."

Is your OS going to behave differently based on the exposed version numbers? If so, I think it'd be wise to use manage versioning internally since programmers are bound to screw it up doing it manually.

I'm queasy about the use of versioned models like this though. It could be irrational, but it reminds me of active-x hell.

In active-X, if two developers tried to update one component, then the component was permanently diverged (at the binary level). If an application was compiled against one of the divergent branches, it would not be compatible the other divergent branch.

Personally, I'm leaning towards a "if the prototypes match, then the link should succeed" approach.

Same here. |0|
(in-joke, somebody read that as lol)


Still too crude, since you can have minor behavioural changes. Mathematica is one of such examples -- each update, it will tweak some commands a little bit, and even though the parameters are the exact same, the functionality may be drastically changed such that automated updating is impossible.

Version numbers do little, especially if you run a gap of a few version numbers, depending upon the scale of the problem (determined mainly by the coder, really).

I am really more interested in compatible breakage -- for example, a previously provided functionality A is now replaced by B and C whereby most cases go for B, and some go to C under some conditions. If automation can still be of use, I do not see why the original code needs to be recompiled -- the slight performance hit should be okay for most. Even after a few more rounds, I see no problem. It really should be the translator's job, to me (the translator will kill me, hehe).

Come to think of it, this is really abuse of translation. Some things just cannot be handled that way. For example, the old C string format had been changed drastically because of massive security holes. Such that, we realised, that one of the tokens is completely dangerous and it is no longer even allowed (let alone support)! Most new implementations will just "politely segfault" if you tried to use it. (I'm talking about the one that outputs the number of bytes written into a memory address thing). I don't know how the translator should handle this: Should it barf (as is currently done), or should it silently drop the message? Or something in between? This is a huge thing to judge, because of the myriad implications.

Sigh.