At this point, it doesn't matter if the user uses the promises that my lib returns, or Bluebirds' or even if they hand-write their own, so long as those adhere to the most basic Promise 'laws' - the most basic API contracts.Ĭan this still lead to breakage at runtime? Yes, it can. finally(), () methods on it, since I want to be as compatible as possible with different users, with different implementations of Promises. So if I am authoring a JS library which I know returns promises and takes promises as part of its API, I'll be very careful how I interact with the received objects. I think it's thanks to the robustness principle.īe conservative in what you send, be liberal in what you accept. What now? How come we don't run into many incompatibilities when different versions of these objects are being passed up, down and around the dependency tree? It's such a useful abstraction over async computations compared to callbacks that many APIs started using them. Sometimes there is sufficient reason to diverge in JS from the built in data types: Take Promises as an example. Which is completely irrelevant to me if all I care about, in this hypothetical example, is concatenating some Texts and comparing their lengths. The two data types may only be different nominally, and the ADT definition and the underlying memory representation may be completely identical.Īs an example, it could have been a minor bugfix to the intersperse function that warranted the release of 1.2.2.1.
#WHERE DOES PANDABAR APP STORE ITS DATA PATCH#
This is quite frustrating, because in the above example only the patch version is different. ‘Text’ is defined in ‘’ in package ‘text-1.2.2.0’ Is defined in ‘’ in package ‘text-1.2.2.1’ Before I started using stack, I've run into the following situation quite a few times with Text and ByteString: Couldn't match type ‘T.Text’ This is what used to happen, and still happens to some extent to this day: Library authors try to rely on the built-ins as much as possible and only diverge when there is sufficient reason to, and with sufficient care and thought. So if I receive a String from one of the libs' APIs I use, and pass it to another, it cannot go wrong because there is just a single String type. I think the first and foremost reason is that the language provides a common basis for primitive types (Number, String, Bool, Null, Undefined) and some basic compound types (Object, Array, RegExp, etc.). And I think it is, in part, thanks to the robustness principle.īelow is my view on why and how. Yes, my experience is indeed that that is not a problem in the Node/JS ecosystem. I was really surprised to discover that this situation basically never happens (I trawled Google, Stack Overflow, etc, looking for examples of people whose applications had stopped working, but who could have fixed it by running dedupe.) So my question is, why is this the case? Is it because node.js libraries never define data structures that are shared outside of the programmers? Is it because node.js developers never break backwards compatibility of their data structures? I'd really like to know!
one of the field names changed), and foo depended on corelib-1.0 and bar depended on corelib-2.0, I'd be a very sad panda: bar's version of corelib-2.0 might see a data structure created by the old version of corelib-1.0 and things would not work very well. Now, what I would expect, is if there was ever a backwards incompatible change to this object (e.g. a URL object) which is passed between foo, bar and the main application. Now, let's suppose that corelib defined some data structure (e.g.
#WHERE DOES PANDABAR APP STORE ITS DATA INSTALL#
By default, when I use NPM to manage a package depending on foo and bar, both of which depend on corelib, by default, NPM will install corelib twice (once for foo, and once for bar).
0 kommentar(er)
