[DotGNU]DotGNU FAQ

[Norbert Bollow]

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