[Mono-list] handling large numbers

Erik Poupaert erik.poupaert@chello.be
Thu, 17 Oct 2002 23:08:52 +0200

Oct 14th, 2002: Crypto, Database work, Debugger, Documentation:
We need either a managed or unmanaged set of classes for handling large
numbers, and some volunteers to expose this functionality to C# (Either as
an internal assembly, or as a set of P/Invoke, Internal call wrappers).

The Mono project seems to have taken over the artificial distinction between
libraries that belong to "the platform" (internal assemblies) and libraries
that don't (P/Invoke).

I definitely understand why Microsoft wants it this way: The platformization
of an huge set of libraries makes the opus magnus difficult to reproduce,
and forces everybody to deploy the whole set, whether a specific application
needs the whole set or not. And control of the platform is definitely a cash
cow, cfr. Windows. The opus-magnus strategy, aka, the trashcan strategy, is
also an ideal strategy for creating an evermoving target. Sun does this
brilliantly with Java.

What I don't understand, however, is how this strategy could ever benefit
open-source developers? Microsoft has other stated and unstated goals than
Ximian, and other open-source developers. And by the way, it is simply
impossible to defeat them at this game. This game requires big money, and
the ability to leverage another monopoly to conquer adjacent territories.

While I agree that sticking as much as possible to the ECMA-standard is a
good thing, I still wonder, why implement it the Microsoft way? Why
introduce this needless complexity?

Why not just reuse code at source-level, leaving the packaging in dlls and
executables up to the developer; and exploit the advantages that this may
have. Any one single compelling advantage that can only be implemented by
reusing code at source-level may very well attract large numbers of
developers to Mono, since Microsoft will, by definition, not be able to
provide the same compelling feature. What is the open-source advantage of
forcing a given set of platform dlls through the throat of developer,
compared to leaving it up the developer how he wants to do it?