3 ms·
Procedure Calls Are the Assembly Language of Software Interconnection (1994) [pdf]
- theaeolist 8y agoIt is particularly sad that many languages treat foreign function interfaces and remote procedure calls as unwanted, debilitated children. I can easily imagine a utopia in which software would plug together via function/procedure/method calls rather than shared files or web APIs or some other popular but improvised and less thought out alternatives. Why are we not there?
- mpweiher 8y ago> utopia in which software would plug together via function/procedure/method calls Hmm...The Fine Article actually argues that procedure calls are too low level for software interconnection, and that is the major reason why we aren't there. (and they haven't really improved in the last quarter century since the article was written). Like the analogy in the title of using assembly language to build large-scale software systems. But you're right that the alternatives are also often quite messy; talking to other systems is generally not considered a first class concern, but rather something you cobble together, somehow, out of parts that aren't necessarily fit for purpose. And I think there are actually good reasons for using web and file APIs (composability, simple GET/PUT semantics) that are independent of other aspects (using HTTP, OS mediation...) but come together in one package. My Objective-Smalltalk[1] is an attempt to build a language where these concerns are first class and separated out, for example with Polymorphic Identifiers[2] to generalise resource/variable access, Constraint Connectors[3] and Object Filters to generalise dataflow and Higher Order Messaging[4] to generalise messaging/procedure calls. One interesting outcome is that once you see these more general concepts in a "pure" setting, you can bring them back to other languages, for examples "Stores"[5]. Not quite as nice as with proper language support, but still very useful. [1] http://objective.st http://objective.st [2] https://dl.acm.org/citation.cfm?id=2508168.2508169 https://dl.acm.org/citation.cfm?id=2508168.2508169 https://www.hpi.uni-potsdam.de/hirschfeld/publications/media/WeiherHirschfeld_2013_PolymorphicIdentifiersUniformResourceAccessInObjectiveSmalltalk_AcmDL.pdf [3] https://dl.acm.org/citation.cfm?id=2889456 https://dl.acm.org/citation.cfm?id=2889456 https://www.hpi.uni-potsdam.de/hirschfeld/publications/media/WeiherHirschfeld_2016_ConstraintsAsPolymorphicConnectors_AuthorsVersion.pdf [4] https://en.wikipedia.org/wiki/Higher_order_message https://en.wikipedia.org/wiki/Higher_order_message [5] https://github.com/mpw/MPWFoundation/blob/master/Documentation/Stores.md https://github.com/mpw/MPWFoundation/blob/master/Documentati...
- pubby 8y agoType systems, exception handlers, garbage collectors, allocators, etc from different languages are rarely compatible with each other.
- mpweiher 8y agoYeah, another reason why we like to user serialised representations to talk to each other.
- abernard1 8y agoThis thought has been around for the better part of 50 years. There are substantial problems even if such a standard did exist (and many have tried), because of the inherent distributed computing problems. Distributed computing requires that systems make tradeoffs, and the semantics of those tradeoffs must be present in the interface. With a local library call, you get all of 1) consistency, 2) availability, and 3) partition tolerance to failure. In a distributed system, that interface must choose which combination of AP, CP, or theoretically suboptimal (not quite AP, not quite CP) mode it wants. The consumer of the interface must negotiate with the provider of that service to enforce these guarantees. In 1994, Sun Microsystems wrote a classic paper why common RPC systems were not the norm at [1]. [1] https://github.com/papers-we-love/papers-we-love/blob/master/distributed_systems/a-note-on-distributed-computing.pdf https://github.com/papers-we-love/papers-we-love/blob/master...
- renholder 8y ago>...formal specifications that provide details beyond type and signature are relatively rare. I'm not sure what, specifically, they're suggesting the alternative is, since their later argument seems to just be to abstract the procedure calls into components and connectors. Most documentation is still just going to list details about the component and/or connector; which doesn't conquer the problem - as referenced above - that the documentation around the specifications will, themselves, still be relatively limited. Since I'm most familiar with RPC in Windows, let's reference EcDoConnectEx[0] as an example of their suggested model. You're consuming a component (MAPI/RPC), without having to implement the connector (RPC), yourself. It's still a gauntlet of documentation and there's nothing outside of the specification readily available to demonstrate the actual implementation. (At least, I don't recall seeing it in the MAPI Headers.[1]) While agree that procedure calls - in and of themselves - might be too low-level for every-day implementation and consumption, you can have the inverse problem of sandboxing like occurred with .NET (before it was ported to [l]unix via .NET Core). Even then, you're now completely abstracting the low-level from the high-level and, whilst that is entirely easy to program for, it's not - precisely - the case that it's easy for debugging back down to the native layer - where an exception might be thrown. I've most famously seen this as a native exception (hResult) being translated into an entirely different exception "reason" in managed code (presumably because either every scenario is almost impossible to program for and/or the native layer was changed and the managed layer wasn't aware of the change and/or never caught up to it). Take this view/perspective with a grain of salt, however, because I haven't programmed in the [l]unix world - outside of some basic Python; so, my anecdotal comment is very much that and should be treated as such. =] [0] - https://msdn.microsoft.com/en-us/library/ee200938(v=exchg.80).aspx https://msdn.microsoft.com/en-us/library/ee200938(v=exchg.80... [1] - https://www.microsoft.com/en-us/download/details.aspx?id=12905 https://www.microsoft.com/en-us/download/details.aspx?id=129...