[ruby-talk:00577] lisence (Re: Re: New feature request! :-))

Hi,

In message "[ruby-talk:00573] Re: New feature request! :-)"
    on 99/08/06, [e-mail] <[e-mail]> writes:

|But here is a question: I think, I have to code some of the converter
|in C or C++ for performance reasons. Perhaps I would have to link them
|statically with the Ruby interpreter. Now I have an interpreter, that
|is not standard Ruby anymore. I have modified it; extend it!

You can consider the interpreter with static linked extensions as mere
aggregation.  So, you don't have to publish source code of your
extension library.

|Now my company would distribute that modified Ruby interpreter (along
|with the concerning scripts, of course) without pointing, where to get
|the source. Is that also allowed?

But, you still need to point where to get the source somewhere in the
distribution.  That's required not because of my lisence, but LGPL,
which covers regex.[ch] in Ruby.  I can agree with your condition, but
I can't change the LGPL condition. sigh.

In addition, strictly speaking, you can't use most of free softwares
under your circumstance.  For example, GPL requires at least pointing
where to get the source, BSD style lisence like Python or Tcl requires
the copyright notice appearing in the supporting documentation.

Ruby's lisence is much weaker than GPL.  Mostly same as Perl's, but
bit more weaker.  If you or your colleage are using any free software
in your project, there must be the legal way to use Ruby.

|They even don't like free software too much! They want someone to make
|responsible for, if anything went wrong. As I have said, that I can
|take responsibility for Ruby within my task area, they let me
|investigate the license issues. If they are convinced, with the
|information I have collected, they will let me go my way .... :-))))))

Really?  I thought free softwares are widely accepted in Europe.

|> the method `foo' should print "this is in foo\n", then return the
|> string value "foo".
|
|Okay! I see, I see. But we could workarount that using a `;' on the end
|of the `print' line, right?

It changes the newline behavior in Ruby.  Small but great change;
enough to make me hesitate.

If the following returns nil, I feel angry. :-)

   def foo
     print "foobar\n"
     "baz"
   end    

Python way is little bit nicer to parser, and users.

   def foo
     print "foobar\n"\
     "baz"
   end

Historically, Ruby did compile time concatenation for literals.  But
when I found out two following facts, I stopped that.

  * you can redefine String's `+' method
  * string concatenation is light enough to abandon

|> I agree.  If I can find good way to do compile time string
|> concatenation, I'd like to add it, maybe in Ruby 1.5.
|
|That would be nice, thank you! :-))))

Only if I find the way; it's too early to appreciate. ;-)

                                                matz.