1.00 What is DotGNU?
1.01 Why do you do this?
1.02 What do you mean with "Free Software"?
1.03 Can I make money using DotGNU?
1.04 What are webservices good for?
1.05 How do you define "webservice"?
1.06 What about other definitions of "webservice"?
1.07 What are the benefits of using a remote webservice, as apposed to executing the same program on your own computer?
1.08 Can webservices have a better user interface than what is possible in a web-browser?
1.09 Is our data stored on the webservice server?
1.10 Can we move to a different webservice provider?
1.11 Can we get source code for the webservice programs?
1.12 Am I obligated to give away my webservice source code?
1.13 What do you mean with "webservice platform"?
1.14 Do I have to pay to use DotGNU?
1.15 What do I need to get to use DotGNU?
1.16 What programming languages are supported in DotGNU?
1.17 Will C and C++ be supported in DotGNU?
1.18 Can I sell webservice programs for DotGNU?
1.19 Can i sell plugins for SEE?
1.20 How can i see DotGNU in action?
1.01 Why do you do this?
Microsoft Corp. 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.).
They have
enough resources to try again and again, so we cannot
relax just because
the original "Hailstorm" plan for destroying all
Microsoft-independent e-commerce has failed.
In the beginning, this threat was the main motivation for starting
the DotGNU project. We wanted to protect the freedom that we
enjoy on the internet, which is characterized by open protocols
which are not encumbered by patents or other restrictions, so that
there are no obstacles to implementing them in Free software. At
the same time, all of the major players in the webservices arena
seemed to be interested in addressing the problem of vendor lock-in.
Since it is the goal of the DotGNU project is to fight for software
freedom in the webservices world, we strive to provide a webservices
platform which provides a solution not only to the technical
problems, but also to the vendor lock-in business problem.
Nowadays, the emphasis in our thinking is more on the offensive.
DotGNU should be seen in the context of the overall desire of
the free software movement to provide businesses with viable
alternatives to proprietary software for all business processes.
One major challenge in this area is to provide a migration path
which provides significant benefits already during the first
stages of the transition to free software. DotGNU helps here,
because the webservices approach allows to make the transition
in multiple small steps.
1.03 Can I make money using DotGNU?
Yes, of course. In fact the main thrust of the DotGNU project
is to provide a suitable platform for serious business
applications of the webservices concept. DotGNU webservices
are useful for every e-commerce website.
For example, you can use webservices to make your website
react to the specific needs of every potential customer with a
business proposal that meets these needs exactly.
Also, if you provide a valuable webservice, it may be
possible to charge for providing this service. For example,
one of the members of the DotGNU Steering Committee runs a
mailing list hosting business which is implemented as a
webservice. The owners of the mailing lists pay the hosting
company for this service.
The DotGNU webservices platform allows you to provide
webservices in a way that gives your potential customers the
assurance that you're not going to "lock them in" by making
it difficult or impossible to move away from your service.
This feature of the DotGNU webservices platform will allow
you to close more sales that you otherwise could.
1.05 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 over a computer network (e.g. the internet
or an intranet) 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.07 What are the benefits of using a remote webservice ?
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.10 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.11 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.12 Am I obligated to give away my webservice source code?
You are not automatically obligated to distribute your source
code, and you are certainly not obligated to just give it away.
However, if you sell webservice services, then your customers
will expect that you make them the "owner of the data" which the
webservice uses, and depending on the exact circumstances that
may indirectly give these customers a right to get the source
code upon request. Here are the details:
If you provide a webservice using a GPL'd webservice program
(which you may have modified), then the "owner of the data"
will be able to obtain the webservices programs under the terms
of the GNU GPL, and this implies in particular that they will
have a right to get the source code of the exact version of the
program which you're using. The terms of the GNU GPL also
require you to make a written promise to this "owner of the
data" that you will be willing to provide the source code upon
request. This ensures that the "owner of the data" will know
about this right to the source code.
The "owner of the data" is typically a paying customer, and the
fact that the customer has a right to get the source code
increases the value of the service you provide. Therefore you
will be able to charge a higher price and/or close more sales.
You can use the DotGNU development tools to program your own
webservices (instead of just modifying the webservice programs
which are distributed with DotGNU, or which others have made
available under the GNU GPL) and then your are not required to
make source code for these webservices available to the customer
who is the "owner of the data". However, even in these
situations where you are not required to make the source code
available to your customers, we strongly encourage you to
provide the source code to your customers under the terms of the
GNU GPL anyway. We believe that this is ethically the right
thing to do, and that it will be good for your business.
1.14 Do I have to pay to use DotGNU?
No. Source code for all the software is available free of
charge. If you're capable of compiling the packages yourself
and combining them into a system that meets your needs, then
you don't have to pay anything for getting and using DotGNU.
Even if that is not the case, DotGNU will not cost you much:
Since everyone has the right to create and distribute CD-ROMs with
DotGNU software, there is no artificial scarcity imposed by
restrictive licensing, and hence DotGNU CD-ROMs will be available
inexpensively.
In addition, it may be expected that vendors of commercial
DotGNU-based webservices will distribute DotGNU CD-ROMs (which
also contain their advertising) gratis as part of their marketing
plan. Hence, at least the client-side parts of the DotGNU platform
(essentially SEE and the plugins for SEE) may be expected to spread
to a good majority of desktop computers quickly.
1.16 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 .
Work is in progress also on Ruby, Python and PHP.
1.19 Can i sell plugins for SEE?
Yes. In fact, if your plugins are good, and you are willing to
make them GPL'd Free Software, you will have the options of
selling them to DotGNU, or marketing them through DotGNU
Marketing.
Alternatively, you are free to market your plugins directly to
people who want to use them. You need to be aware however that
the see-plugin library (which implements the standard interface
between the plugin and SEE) is licensed under the terms of GNU
GPL. Therefore, if you want to use this library (which is
highly recommended) your plugins need to be Free Software with a
GPL-compatible license. This may make it difficult to sell a
large number of copies of your plugin. It may be your best
option to sell just one copy of each version of your plugin to
DotGNU (licensed under GNU GPL), thereby enhancing the value of
the whole DotGNU system.
2.03 What packages need to get ready in time for DotGNU 1.0?
Here is the current draft list of development projects
that are needed for "DotGNU 1.0"... this list
is not meant to limit the scope of DotGNU (all other good
stuff will be included in "DotGNU 1.0" if it is
ready on time) but these are the things that are considered
"must have" requirements for "DotGNU 1.0". We
cannot release "DotGNU 1.0" until all of these
components are implemented and well-tested.
DotGNU projects list, Version 0.2
infrastructure
==============
1. SEE (Secure Execution Environment)
- possibly implemented as 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. Some DotGNU webservices server software
- 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
6. Virtual Identities system
- a useable and secure solution to the authentication and
authorization problems
development tools
=================
7. C# -> CLR compiler
- written in C
8. C# class library
9. CLR -> CLR optimizer
10. CLR debugger
webservices
===========
(all of the below should be usable both as webservice components and as
webservice application)
11. 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.
12. phpGroupWare webservice components and webservice application
13. DotGNU webservice server checker
- a tool to potentially falsify the claim that a given webservice
server meets the requirements of a DotGNU webservice server.
14. Instant Messaging system
- DotGNU will use the Jabber protocol and use code from JOSS, a
popular Jabber server which is Free software with now
GPL-compatible licensing.
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.09 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
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. 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 is a volunteer-driven project where everyone is given the
freedom to work on whatever they consider to be important, and
what has to do with creating a successful webservices platform
which is founded on the GNU philosophy.
2. The DotGNU Steering Committee (which has been appointed by
Richard Stallman, the founder and leader of the GNU project)
will, when necessary, serve as "high court" to resolve any
conflicts between contributors, and it will work to make
sure that the project remains faithful to its mission.
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.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.]
