The DotGNU FAQ

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, C#, Ruby, Python and PHP.

1.01 Why do you do this?

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 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.04 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.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.06 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://www.dotgnu.info/pipermail/developers/2001-November/001252.html * http://www.dotgnu.info/pipermail/developers/2001-November/001253.html * http://www.dotgnu.info/pipermail/developers/2001-November/001254.html * http://www.dotgnu.info/pipermail/developers/2001-November/001255.html

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.08 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.09 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.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.13 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.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.15 What do I need to get to use DotGNU?

If you just want to be able to use DotGNU webservices that are already offered somewhere on the internet, all you need will be a DotGNU CD-ROM which will be available from webservice providers inexpensively or even gratis. The client-side parts of the DotGNU platform will be made available for all operating systems which are commonly used on desktop computers.

Since DotGNU is part of the GNU project, the software for creating or hosting webservices will be included with every GNU/Linux or GNU/Hurd distribution.

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.17 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 like you normally install software. However you cannot use C or C++ to implement webservice programs that are meant to run in the Secure Execution Environment (SEE), like it will be possible with e.g. Java, Ada, C# and Perl - at least not until someone solves the difficult issues of compiling C to some kind of portable intermediate representation in such a way that the Secure Execution Environment can efficiently verify that the program is not trying to do something malicious.

1.18 Can I sell webservice programs for DotGNU?

Yes. If you have a good webservice program that you're willing to put under GNU GPL, then you may be able to sell it to DotGNU. You can also market your webservice programs directly. It is not necessary for webservice programs which will be executed in the Secure Execution Environment SEE (either on a webservice server or on the client's PC) to use a GPL-compatible license. The DotGNU libraries that you will want to use from such programs all come with a "linking exception" (see below) that allows you to use them for any webservice program, regardless of how your program is licensed.

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.

1.20 How can i see DotGNU in action?

Think of a good webservice. Then implement those parts of DotGNU which are still missing and which are needed by this webservice. Then implement the webservice, announce it, and see how people are using it.

For example a simple Webservice framework has been maturing for Apache based XmlRpc webservices . The DGEE has been demonstrated and tested with the Portable.Net VM as the engine . It has proved to be stable and robust as well as supports Message Queueing.

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:

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 (developers@dotgnu.info, developer@dotgnu.info, dotgnu-developers@gnu.org) 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.info/projects.html
http://www.dotgnu.info/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 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.04 Can I start a development project which is not on this list?

Sure. 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.08 How were the projects on the "DotGNU projects list" chosen?

There aren't any precise, well-established criteria right now. The main principles are:

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.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.]