We can only guarantee the binary compatibility with the released versions, cause the point of the development versions is that things shift around and change.
As I understand when interfacing with an other language, the version of the compiler shouldn't be important, right? So the binary compatibility could only change for special features? What would that be, classes?
So in practice, it might not be necessary to provide a package for each release?
It
is necessary, because from release to release the interface sections of the core units will likely have changed (new intrinsics here, new Delphi compatible types, classes, variables there, maybe a bugfix here and there that changes some function signature and let's not forget a new virtual method for the one or other class) and thus anything that depends on them needs to be recompiled. And some times even the version number of the PPU files changes, because something new was stored into the PPUs (mainly when a new language feature is added). This again requires a recompilation of all units. And the dynamic package system
will check both the interface checksums (that are stored in the PPUs) and the PPU versions to ensure that there aren't any problems due to a differing binary interface.
In theory one
could achieve binary compatibility by only changing things in the implementation section (and one can in fact use this with dynamic packages), but from release to release that is a maintenance burden we're not going to support. Not to mention the development versions.
It's
not as simple as calling a library, because the with a library you only have a code address, nothing more (and if you import a C function returning
int as returning
void instead nothing bad will happen), with units, no matter if statically linked or using dynamic packages you have the whole range of mangled names, VMTs, type information, etc. that needs to be kept consistent.
At work we use C++ and our code is split over many libraries and we use abstract classes (aka interfaces) a lot. Since a few years we have a build system that automatically generates a complete build with which you can work, but before we had that it was a nightmare to add new virtual methods to an interface or to refactor things, cause you had to make sure manually that all dependant libraries are recompiled with the correct headers. And we control all the source that's involved there. Now imagine this in a situation where you have binary code from multiple vendors.
No. We're definitely not doing something like that. We'll have new binaries each version and no guaranteed binary compatibility in the development versions. Just like it is
today.