[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[DotGNU]DotGNU FAQ
From: |
Norbert Bollow |
Subject: |
[DotGNU]DotGNU FAQ |
Date: |
Fri, 23 Nov 2001 16:55:35 +0100 |
I've done more work on the DotGNU FAQ. Here is the revised version...
The DotGNU FAQ
Version 0.01
About DotGNU
~~~~~~~~~~~~
1.00 What is DotGNU?
1.01 Why do you do this?
1.02 What do you mean with "Free Software"?
1.03 What are webservices good for?
1.04 How do you define "webservice"?
1.05 What about other definitions of "webservice"?
1.06 What are the benefits of using a remote webservice, as apposed to
executing the same program on your own computer?
1.07 Can webservices have a better user interface than what is possible
in a web-browser?
1.08 Is our data stored on the webservice server?
1.09 Can we move to a different webservice provider?
1.10 Can we get source code for the webservice programs?
1.11 What do you mean with "webservice platform"?
1.11 What programming languages are supported in DotGNU?
1.12 Will C and C++ be supported in DotGNU?
Contributing to DotGNU
~~~~~~~~~~~~~~~~~~~~~~
2.00 Where can I contribute?
2.01 How do I filter mail from the developers list into a separate
folder?
2.02 What software development projects are there in DotGNU?
2.03 What packages need to get ready in time for DotGNU 1.0?
2.04 Can I start a development project which is not on this list?
2.05 I'm starting a development project. What name should I use?
2.06 What are the requirements for starting a DotGNU development project?
2.07 How were the projects on the "DotGNU projects list" chosen?
2.08 Do we have some degree of democracy in DotGNU?
Licensing issues
~~~~~~~~~~~~~~~~
3.00 What software licenses does DotGNU use?
3.01 Does the linking exception carry over to derivative works?
3.02 What about programs which access each other through network
protocols. Is that a form of linking?
3.03 Is it possible to establish strong copyleft for webservices,
that allows them to be used only by Free Software?
3.04 Why don't you use the LGPL for libraries?
About DotGNU
~~~~~~~~~~~~
1.00 What is DotGNU?
DotGNU is a Free Software project to create a platform for
webservices that can be written in a variety of different
programming languages including Java and C#.
1.01 Why do you do this?
Microsoft is trying to catch all e-commerce in their .NET and lock
everyone in. For details see the article "Tempted by .NET?" by
Richard Hillesley: Linux User No 15 (Oct 2001), p. 15-21.
http://www.linuxuser.co.uk/articles/issue15/lu15-Cover_feature-Tempted_by_net.pdf
We consider these plans to be evil, and we want to prevent them from
being successful. At the same time, the webservices approach is
truly useful for some things, if the vendor lock-in problem can be
solved. So we provide a webservices platform which provides a
solution not only to the technical problems, but also to the vendor
lock-in business problem. E-commerce websites will prefer this
system, and thereby we can prevent the internet from falling under
Microsoft's control.
1.02 What do you mean with "Free Software"?
In "Free Software", the word "free" refers to freedom, not price.
For the definition of "Free Software" please refer to
http://www.fsf.org/philosophy/free-sw.html
For an explanation of why this is very important please refer to
http://thinkcoach.com/free-software.html
1.03 What are webservices good for?
When a program is implemented as a "webservice", its functionality
can be used by other programs which can be implemented in any
programming language, and which can run on any computer which is
connected to the internet. This makes it possible for example that
multiple users in different parts of the world can interact with a
single set of data.
1.04 How do you define "webservice"?
"Webservices" are any services that are offered on the web
(regardless of what technology is used to provide them).
In order to turn this statement into an actual definition,
these explanations need to be added:
a) With "service" we mean not only that some functionality is
provided, but that there should also be some description of
this functionality, namely how the service should be used and
what it provides.
b) With saying that the service is "offered on the web" we mean
that it's offered on the internet via standard protocols,
i.e. protocols that are open, widely published, and freely
available for anyone to implement.
It is sometimes useful to distinguish between "webservice
components" which are meant to be used by other webservices, and
"webservice applications" which are meant to be used by humans
more directly. Both "webservice components" and "webservice
applications" are "webservices" as defined above.
1.05 What about other definitions of "webservice"?
A definition attempt by the Stencil Group has been discussed in some
detail on the DotGNU developers mailing list, in these messages:
* http://archive.dotgnu.org/pipermail/developers/2001-November/001252.html
* http://archive.dotgnu.org/pipermail/developers/2001-November/001253.html
* http://archive.dotgnu.org/pipermail/developers/2001-November/001254.html
* http://archive.dotgnu.org/pipermail/developers/2001-November/001255.html
1.06 What are the benefits of using a remote webservice, as apposed to
executing the same program on your own computer?
Apart from special circumstances (like when you need to process huge
amounts of data that your local computer cannot handle) there is a
benefit to using a webservice only when the same set of data needs
to be accessed by multiple people, or when a user needs to be able
to access the same set of data from multiple computers.
For example, the straightforward way to implement mailing list
hosting is to do it as a webservice, and that is exactly what the
implementors of Mailman, the GNU mailing list program, have done.
On the other hand there is little benefit from implementing e.g. a
text editor as a webservice unless there are features to allow
multiple users to edit the same file at the same time.
1.07 Can webservices have a better user interface than what is possible
in a web-browser?
Yes. The DotGNU Secure Execution Environment (SEE) allows the
webservice to execute code on the user's desktop computer without
creating a security risk for that computer. In particular, SEE
is meant to facilitate the creation of good, very portable user
interfaces.
1.08 Is our data stored on the webservice server?
Data can be stored either locally or on the webservice server. If
multiple users need to interact with the same set of data, then it
should probably be stored on the webservice server.
This raises the legitimate concern of whether a webservice provide
can "lock in" customers by making it inconvenient or impossible for
them to get at their data; this issue is addressed in the following
questions.
1.09 Can we move to a different webservice provider?
The DotGNU webservice server requires that for each webservice and
each set of data that it acts on, there is an "owner of the data"
who has the right to download the entire set of data together with
the program which implements the webservice. Program which have
been downloaded in this way can be executed in any DotGNU Secure
Execution Environment on a desktop computer or on a DotGNU
webservices server.
(This means that when there is a need for an application to use data
from multiple sources, where no-one has ownership rights to all the
data, then the application must be divided into multiple webservice
components.)
1.10 Can we get source code for the webservice programs?
If all of the following conditions are met, then the webservice
provider is required to distribute the source code for the webservice
program to you, upon your request:
* The webservice program has been licensed to the webservice
provider under the terms of the GNU General Public License, or it
is a derivative work of such a program.
* The webservice program runs on a DotGNU webservice server.
* You are recognized as an "owner of the data" for this webservice.
Then the webservice server will upon your request distribute the
program to you in binary form. According the terms of the GNU
General Public License, this implies that the webservice provider
must upon request distribute the source code for the webservice
program to you.
1.11 What do you mean with "webservice platform"?
With "webservice platform" we mean a collection of software that
allows you to create and deliver useful webservices:
* A (distributed) server platform that can host webservice
components in a reliable manner (without any single point of
failure).
* A Secure Execution Environment (SEE) that allows end-users to
securely execute client-side components of webservices.
* A collection of standard webservice components.
* Protocols and implementations of these protocols for connecting
webservice components with each other.
* System administration tools that allow to maintain distributed
systems of webservices in an orderly manner.
1.12 What programming languages are supported in DotGNU?
We want to support Java in the same way as C#/CLR (as per Microsoft's
ECMA specs) will also be supported. As soon as Parrot (the bytecode
system of Perl6) is available, it will probably be added to the list
of bytecode systems that we want to support.
Note that with the support for Java bytecode, all other programming
languages that can be compiled to Java bytecode will also be
available, for example Ada95. Also, all programs that are written
for .NET (for example in Visual Basic) should work with DotGNU.
In addition, there is work in progress on porting the "Mercury"
programming language of the University of Melbourne so that it
can be compiled using the development tools of DotGNU Portable.NET .
1.13 Will C and C++ be supported in DotGNU?
Code which is written in C or C++ can be used with DotGNU, *if* it
is distributed with DotGNU or otherwise installed on the end
user's PC like you normally install software - it cannot be
transported as bytecode to a Secure Execution Environment (SEE) on a
remote machine, like it will be possible with e.g. Java, Ada, C# and
Perl. Hence C and C++ are fine for implementing parts of DotGNU,
but they will not be an acceptable language for implementing
webservices - at least not until someone solves the difficult issues
of compiling C to some kind of portable intermediate representation.
Contributing to DotGNU
~~~~~~~~~~~~~~~~~~~~~~
2.00 Where can I contribute?
The best way to get started is probably to subscribe to the three
main mailing lists and send a message to one of them (wherever you
feel it would be most appropriate) saying what kind of thing you'd
like to help with, and what your skills are.
The main mailing lists are:
* http://subscribe.dotgnu.org/mailman/listinfo/developers
* http://subscribe.dotgnu.org/mailman/listinfo/arch
* http://subscribe.dotgnu.org/mailman/listinfo/auth
2.01 How do I filter mail from the developers list into a separate
folder?
Make a procmail recipe that filters on the List-ID: header. This
header is guaranteed to always be the same, regardless of which of
the three available email addresses (address@hidden,
address@hidden, address@hidden) people use for
posting to the list.
2.02 What software development projects are there in DotGNU?
Please refer to the website:
http://www.dotgnu.org/projects.html
http://www.dotgnu.org/proposals.active.html
2.03 What packages need to get ready in time for DotGNU 1.0?
Here is the current draft list of development projects
that would together form "DotGNU 1.0"... the idea is to have a
not too long list of development projects for now; more can be
added after "DotGNU 1.0" has been released.
DotGNU projects list, Version 0.1
infrastructure
==============
1. SEE (Secure Execution Environment)
- a daemon, written in C++
- supports plugins
- must run on all major desktop systems
- must have support for assistive devices (for disabled users)
2. CLR plugin for SEE
- must run on all major desktop systems
3. Java VM plugin for SEE
- must run on all major desktop systems
4. PHP plugin for SEE
- must run on all major desktop systems
5. Parrot plugin for SEE
- must run on all major desktop systems
(Note: We need this for DotGNU 1.0 only if Parrot itself is ready
by then.)
6. DEE (Distributed Execution Environment)
- only needs to work on GNU systems
- executes webservice code in a SEE on the webservice server,
but also allows users to download the webservice code
(Anyone who is able to execute something on the server is
also able to download the program and execute the program
locally.)
- allows the owner of data to download the data
- facilitates distributed hosting of webservices
- must support transaction logging and roll-back
- Any program that works under DEE must also work under SEE
(However the converse of this will not be true.)
7. XML-shell
- system administration tool for DEE
8. Virtual Identities / auth project (a "horse race", no single project
endorsed at this stage)
development tools
=================
9. C# -> CLR compiler
- written in C
10. C# class library
11. VisualBasic -> CLR compiler
- written in C
12. CLR -> CLR optimizer
13. CLR debugger
webservices
===========
(all of the below should be usable both as webservice components and as
webservice application)
14. searchable webservice directory
- Should be able to query listed webservices for the information,
i.e. webservice maintainers can maintain all the information
for directories on their own server, they don't need to separately
maintain listings in multiple directories
- Must be usable for specialized directories, like e.g. a directory
of software development projects.
15. phpGroupWare webservice components and webservice application
16. distributed Savannah
17. load-balancing system
18. file storage/retrieval system
- allows remote storage of files, allowing to give others limited
or full access rights.
19. distributed backup system
20. Appointment Maker
- a webservice that manages the appointment-making process
21. DotGNU webservice server checker
- a tool to potentially falsify the claim that a given webservice
server meets the requirements of a DotGNU webservice server.
- For webservices which store data in the DEE, this can only
be used by the owner of the data (i.e. by someone who has
the right to export the data).
22. Instant Messaging system
- If the GPL-incompatibility of the licensing of the current JOSS
version cannot be resolved, we may want to fork version v1.1.3
which was the last version that was licensed under GPL.
- An interesting alternative without any licensing problems is
the planned instant messaging system of Bayonne.
2.04 Can I start a development project which is not on this list?
Sure. DotGNU is not a hierarchy. The above list should be
understood as a recommendation for areas to focus on. It is
not meant to stop you from other things that you consider to be
important.
2.05 I'm starting a development project. What name should I use?
Just use any name of your choice. When your project has been
accepted into DotGNU, you can call it "<Projectname>, a Project of
DotGNU". Therefore it is not necessary for your Savannah project
name to contain the string "dotgnu".
2.06 What are the requirements for starting a DotGNU development project?
You need to make a commitment to putting your code under the GNU
General Public License, possibly with linking exceptions as
appropriate (for details about this, see section 3 of this FAQ).
Also you need to make sure that there are no legal hooks on the
software that would prevent it from being truly Free Software.
For example, if you have a trademark or servicemark on the name
of the program, then you need to give us a license which allows to
use this mark in connection with this program and derivative works
thereof, which which also gives us the right to give these rights to
others. Similarly, if you have patents that are related to your
development project, then you need to make them available through a
free patent license. If you have applied for patents which have not
been granted yet, then you need to make a contractual commitment to
making these patents available though such a free patent license if
they are granted.
2.07 How do I write a "Disability Impact Statement"?
Here is an example... (in the case of SEE)
Disability Impact Statement
~~~~~~~~~~~~~~~~~~~~~~~~~~~
The DotGNU Secure Execution Environment (SEE) is the part
of the webservices system where client-side components of
webservices are executed; this includes in particular the
parts of the program which implement the user interface.
Support for assistive devices for disabled users is provided by
specialized SEE plugins. Each of these plugins provides an API
for one assistive device; the plugin can also be used without
the assistive device in a simulation mode that allows
(non-disabled) software developers to easily get a first
impression of the user experience of any given program for
disabled users.
2.07 How were the projects on the "DotGNU projects list" chosen?
There aren't any precise, well-established criteria right now. The
main principles are:
1. Uphold the standards and ethical principles of GNU and
FreeDevelopers.
2. DotGNU must be a solution to the vendor lock-in problem for
webservices. (See question 1.08)
3. Within the constraints 1. and 2., cooperate as much as
possible with other projects.
4. Within the constraints 1., 2. and 3., do whatever it takes to
make DotGNU a winner.
2.08 Do we have some degree of democracy in DotGNU?
So far the only "institution" in DotGNU is the DotGNU Steering
Committee, which has been appointed by RMS. So right now DotGNU
cannot be a democracy in the usual sense, simply because the
necessary democratic institutions and procedures have not been
established.
It would not be easy to turn a Free Software project like DotGNU
into a true democracy. It would have to be a _constitutional_
democracy because there are standards and ethical principles of
GNU and FreeDevelopers which cannot be allowed to be simply changed
by a majority vote. Also the core of the DotGNU vision (which makes
it a solution to the vendor lock-in problem for webservices) may be
refined, but not discarded. There would need to be structures in
place which prevent people who do not agree with these key things
from "hijacking" DotGNU. We would need to have a constitution which
defines some democratic institutions and their responsibilities, as
well as procedures for selecting the members and the leaders of
these institutions, as all as some principles which the democratic
institutions cannot change without the approval of the sponsoring
organizations (FreeDevelopers and the GNU project.) Setting this
all up in a way that actually works will require a lot of effort, as
well as trial-and-error. Doing this here in DotGNU would be a huge
distraction, which we cannot afford.
So what DotGNU needs is a simpler structure that will still give
us most or all of the benefits of a constitutional democracy. We
have established such a structure, as follows:
1. DotGNU has a GNU-appointed Steering Committee.
2. However this Steering Committee does not have things under
control. The Steering Committee guides the DotGNU process
by making recommendations to the projects. (Example: The
"DotGNU projects list" is such a _recommendation_ document. It
is not meant to prevent people from working on things that are
not on the list.)
3. Most actual decisions are made in the development projects.
Each project has a leader who establishes a decision-making
process. This does not need to be a democratic process,
because projects which make bad decisions can be forked.
(This possibility of forking makes mismanagement much
less likely to happen, and hence there will probably not
be a need for many forks.)
4. Mailing lists have been established for facilitating a free
flow of discussions on various matters related to DotGNU.
Use of the lists in ways which harm the DotGNU project will
not be tolerated. Here are some examples of behavior which
will not be tolerated:
- making FUD-like claims without substantiating them upon request
- "name calling"
- advertising or recommending proprietary software in any way
- making postings which seem to be illegal according to the
laws of the country where the mailing list server is located
(currently the USA).
People who do such or similar things may be moderated,
kicked off the list, or banned. The offending postings may
be removed from the list's archives.
Licensing issues
~~~~~~~~~~~~~~~~
3.00 What software licenses does DotGNU use?
All official software development projects of the DotGNU
meta-project use the GNU General Public License (GNU GPL).
For Libraries which are intended to be linked with third-party
programs that may not have a GPL-compatible license, as a special
exception such linking is allowed.
3.01 Does the linking exception carry over to derivative works?
If you create a derivative work of pnetlib or any library which is
licensed as "GPL plus linking exception", then it is up to you
whether want the linking exception to carry over to your derivative
work. If you leave the exception in the text, then it applies to
your version.
3.02 What about programs which access each other through network
protocols. Is that a form of linking?
No. A GPL'd program can use any kind of webservice regardless
of how the webservice software is licensed, and GPL'd webservice
software can be used by any program regardless of that program's
license.
3.03 Is it possible to establish strong copyleft for webservices,
that allows them to be used only by Free Software?
It is probably not possible to construct a Free Software license
(which operates through copyright law) which would have this effect.
3.04 Why don't you use the LGPL for libraries?
Using GPL plus linking exception has several advantages. One is
that this makes it more convenient to reuse parts of the code
(possibly with modification) in GPL-licensed files.
Also, you can exclude native methods from the linking exception.
This is done in the license on the C# library, "pnetlib", which
is distributed under these terms:
The source code for the library is distributed under the
terms of the GNU General Public License, with the following
exception: if you link this library against your own
program, then you do not need to release the source code
for that program. However, any changes that you make to the
library itself, or to any native methods upon which the
library relies, must be re-distributed in accordance with
the terms of the GPL.
We call this the "GPL plus linking exception", which is also
used by the GNU Classpath project.
We aren't trying to restrict the use of the library by any kind of
commercial entities. However, a proprietary software company could
produce their own proprietary runtime engine that has
"enhanced" native method support of some kind. Under the terms
of the LGPL, they would be obligated to release the
declaration of the native method in the C# system library. For
example:
extern int enhanced_method(string arg1, int arg2);
But would they be obligated to release the source code to the
native method's implementation under the terms of the LGPL?
Because it is in a separate program (their runtime engine), it
isn't strictly part of the library. The result would be a C#
library that is useless without their proprietary native method
implementation. This state of affairs is undesirable.
Under the terms of the GPL, we can require that the source code
to native methods must also be available, or the library
modification is disallowed.
This is why we have decided to use the GPL with the linking
exception described above.
[Aside: by "native method" we mean any method that is
implemented in something other than IL bytecode. This includes
PInvoke functions and "internalcall" methods, among others.]
Greetings, Norbert.
--
A member of FreeDevelopers and the DotGNU Steering Committee: dotgnu.org
Norbert Bollow, Weidlistr.18, CH-8624 Gruet (near Zurich, Switzerland)
Tel +41 1 972 20 59 Fax +41 1 972 20 69 http://thinkcoach.com
Your own domain with all your Mailman lists: $15/month http://cisto.com
- [DotGNU]DotGNU FAQ,
Norbert Bollow <=
- Re: [DotGNU]DotGNU FAQ, Bill Lance, 2001/11/23
- Re: [DotGNU]DotGNU FAQ, tali streit, 2001/11/23
- Re: [DotGNU]DotGNU FAQ, Bill Lance, 2001/11/24
- Re: [DotGNU]DotGNU FAQ, Norbert Bollow, 2001/11/24
- Re: [DotGNU]DotGNU FAQ, Bill Lance, 2001/11/25
- [DotGNU]Market research (was Re: DotGNU FAQ), Norbert Bollow, 2001/11/26
- Re: [DotGNU]Market research (was Re: DotGNU FAQ), Bill Lance, 2001/11/26
- Re: [DotGNU]Market research (was Re: DotGNU FAQ), Bill Lance, 2001/11/27
Re: [DotGNU]DotGNU FAQ, Fergus Henderson, 2001/11/25