[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
Re: [DotGNU] DotGNU policies
Re: [DotGNU] DotGNU policies
Tue, 25 Mar 2003 16:50:19 +0100 (CET)
Peter Minten <address@hidden> wrote:
> > If it "also means" this, then it goes too far IMHO.
> I agree. However, the pure rule does not say anything about the language
> functions are written in, it just says functions have to be
> accessible using C. If bytecode interpreters have to be hacked than
> that is clearly a sign that the functions are NOT accessible using
> C. Let me rephrase:
> * All essential DotGNU code shall be accessible from any language
> provided it can access functions written in C. It shall only be
> allowed to write such essential DotGNU code in a certain language
> if it's possible to call functions in the language from C in a way
> that does not require modifications of the language compiler or
> Compatibility is our business. True compatibility does not mean
> assimilation (compiling everything down to one bytecode) but
> integration (providing ways to access stuff from one language from
> another). Strange hacks in compilers or interpreters should not
> be needed however. If that is needed it's a sign that a language
> is uncapable of performing the job.
> > Peter, maybe you can post a revised working of your policy proposal
> > which does not have this controversial implication?
> See above. The rule is a little complicated now, but it does the job.
Hmmm... I think that is too complicated.... official policies need to
be clear-cut and simple otherwise we'll sooner or later get flame wars
on what is the correct interpretation.
Actually, why not simply make it a policy of DotGNU that we want all
essential functionality implemented either in C or as a webservice?
(We have a compiler that can compile C to IL and to JVM bytecode, as
well as the ability to make, without much trouble, functions which
are written in C accessible from just about any language. So this
rule fits well with your "compatibility is our business" mantra :-)
I think that this proposed policy would be a good application of the
section "Which Languages to Use" of the GNU coding standards. Quoting
from http://www.gnu.org/prep/standards_7.html :
When you want to use a language that gets compiled and runs at
high speed, the best language to use is C. Using another language
is like using a non-standard feature: it will cause trouble for
users. Even if GCC supports the other language, users may find it
inconvenient to have to install the compiler for that other
language in order to build your program. For example, if you write
your program in C++, people will have to install the GNU C++
compiler in order to compile your program.
C has one other advantage over C++ and other compiled languages:
more people know C, so more people will find it easy to read and
modify the program if it is written in C.
So in general it is much better to use C, rather than the
But there are two exceptions to that conclusion:
* It is no problem to use another language to write a tool
specifically intended for use with that language. That is
because the only people who want to build the tool will be
those who have installed the other language anyway.
* If an application is of interest only to a narrow part of the
community, then the question of which language it is written
in has less effect on other people, so you may as well please
I'll add that DotGNU is specifically about empowering people to
implement webservices in any of a large number of popular programming
languages. So it makes sense for DotGNU to include webservices that
are implemented in multiple languages, as this will serve both as an
example for DotGNU's users (webservice developers) and as a real-life
test of the multi-language nature of DotGNU.
Founder & Steering Committee member of http://gnu.org/projects/dotgnu/
Free Software Business Strategy Guide ---> http://FreeStrategy.info
Norbert Bollow, Weidlistr.18, CH-8624 Gruet (near Zurich, Switzerland)
Tel +41 1 972 20 59 Fax +41 1 972 20 69 http://norbert.ch