On Wed, Nov 12, 2008 at 09:47:18PM +0100, Ondrej Certik wrote:
> it's a very nice and honest email. Kirr has done a stellar job over
> the past year and half and we definitely would not be as advanced with
> sympy without him. I'll reply to his arguments in my next email.

I'll use my mail to reply mainly to Kirr (I hope he is still listening)
because I hugely respect and value a man who has invested a large amount
of quality time in a community project.

Kirr, you have been a fantastic actor of the project. You are now saying
that you are tired. This is actually a fairly common problem. We all
fight with lack of time, to many various interests. Software development
comes with its load of difficulties and disappointments. Too much
sacrifices ruin private life.

I am off course very sad if you quit this project that I follow (without
contributing, sorry) and in which I believe. However, what I really want
is to thank you for all your work. I hope you had as much fun as
possible, and I hope that your will keep good memories of your time with
sympy, rather than the reasons that made you quit. And besides, no
decisions is irreversible. I believe that you will have friends in the
sympy team whether you are contributing or not. Life and friendship are
more important than software. 

> But I'd like to use this occasion to make a survey among our
> developers and users ---- do you think we should stay with BSD, or
> switch to LGPL?  I am interested in all opinions from anyone. Whenever
> there is some occasion, I am discussing this with people around sympy
> and so far my observation is that most people either prefer BSD, or
> don't mind either, but would like to hear good arguments why LGPL
> should be better. There are also some who clearly prefer LGPL, for
> example Kirill or some people from the Sage community, but I think
> given all the circumstances (i.e. sympy aspiring to become the
> symbolic manipulation library for Python, and together with numpy,
> scipy, matplotlib, mayavi and others form a BSD like environment for
> scientific computing, that people can build on and given the community
> where sympy belongs), the right license for sympy is BSD.

We have discussed this a few times, including over a few beers in Prague,
you know my point of view. I won't dwell on it long.

Briefly. I personally realized that I don't care much about the license
of the software that I write. I care more that it is used by as many
people as much as possible. The thing that worries me most with software
is the amount of wheel reinvention, and lousy, half-complete,
implementations of a solution to a given problem. This is why I believe
free software has a future. This is indeed the Lessig point of view. The
reason I feel a BSD license help is that many companies (especially large
ones) are not afraid of hiring scores of developers to reinvent the
wheel, just because they want to possess it and control it. The driver
for free software adoption in companies is not cost, but control. 

Of course the license debate changes whether you consider your software
as a component, that needs to be integrate in a larger infrastructure, or
as a finished good. Linux, (GPL, fantastic example of free software
success) is clearly a finished good. Wine (now LGPL) may also be a
finished good. Scientific computing libraries on the other hand, are not
finished goods. A company, or a research lab, may want to fork them to
keep a competitive advantage, and maybe not even redistribute the
resulting binaries. And that's fair enough by me, because I think the
world is a better place if these people use my software as a start,
rather than building on crappy bases. Besides, if they later decide to
share, it will be possible if the built on common abstraction. Finally, I
hope that as the world evolve, people (mostly managers and lawyers) will
understand the gain that there is to share 90% of the code, may it be
with 10% kept secret for a competitive advantage.

For me the golden example of successful free scientific software is VTK.
VTK is a 3D plotting library. 3D plotting is a forever-reinvented
problem. Each particular application is actually fairly simple, but when
you try to do something a bit more general, it gets really hard. So
people (companies, research labs) start out with a specific problem they
want to solve, and code a quick implementation, then as they evolve,
their small implementation grows to be a huge one, and most of the time
lies on crappy abstractions and data structure. VTK was born as a spin
off of GE: the code used in medical visualization was split off to a
start up (Kitware) and BSDed. GE still have their own proprietary bunch
of codes, for their medical devices, but VTK lives on, and unites the
efforts of many companies and labs with diverging problems and goals. In
the case of VTK, individual actors have learned that they need to
contribute back, because the cost of have their own abstraction and
algorithm to maintain and to impedance-match with the rest of the world
was very high. They make a careful decision as to what is open-sourced
and what isn't.

This is my model of development, and my 2 cents.

Gaƫl

--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"sympy" group.
To post to this group, send email to sympy@googlegroups.com
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at http://groups.google.com/group/sympy?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to