[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Octave and Guile?

From: John W. Eaton
Subject: Octave and Guile?
Date: Thu, 14 Sep 2000 00:28:08 -0500


I'm the primary author of GNU Octave, an interpreted language for
numerical mathematics with a syntax similar to Matlab.

Would there be any interest within the Guile community for some sort
of merger of Octave and Guile?

I am asking because I was recently approached with the idea of merging
parts of Octave with Python, and although it seemed like a nice idea
at first, I am no longer so sure about it.  While thinking about the
advantages and disadvantages of merging Octave with another scripting
language, I started thinking more about how this might work with
Guile, and wondering whether it might be a better choice.

A merger of Octave and Python would give Octave a lot of active
developers of things not related to numerical analysis and Python
would gain better numerical tools.  Eventually though, I think the
goals of the Python community are to subsume Octave and implement
everything directly in Python, with Python syntax and semantics,
possibly with the addition of some new operators for matrix algebra.
The more I think about it, the more it seems that it is not a very
clean solution, since some of the current Python syntax and semantics
don't match well with the way Octave works, or function in a way that
people familiar with Matlab or other numerically oriented languages
would expect.

Aside from language issues, a problem with Python at this point is the
continuing license dispute.  Also, it seems as though the people who
are currently working on numerical extensions to Python want to
continue to distribute those extensions under very permissive terms,
but Octave is distributed under the terms of the GPL, and I am not
really interested in writing freely available code that is not
protected by the GPL.

Would a merger of Octave and Guile be better?

Perhaps merger is not the right word -- I'm not talking about merging
numerical tools with the Guile core, but about replacing Octave's
interpreter with Guile, and writing a translator for Octave's language
into Guile.  As I imagine it, this would also mean that (nearly) all
of Octave's numerical capabilities would be available directly from
Guile code too.  Octave would also likely receive a facelift to remove
bad features (Matlab compatibility would not be a significant goal)
and to focus the language on numerical capabilities only.

I think it is important for this application to use a translator
instead of expecting users to write Scheme code directly.  Although
Scheme is probably a good language for many tasks, and some hardened
Scheme hackers may actually prefer to write (+ a (/ (* b c) (- d e))),
most people I have worked with who do any numerical programming would
much prefer to write things like a + b * c / (d - e), since it looks
more like what they write on paper.  It also seems natural to me that
one would use different languages for different problem domains and
this idea seems to fit well with one of the primary goals of the Guile
project (universal scripting).

I don't see as much activity (or hype) centered around Guile as I do
around Python, so I am wondering if there are enough people working on
Guile to make a merger really take off.  What I'm looking for is a way
to get better graphics, better support for OS tools (good
interfaces for system calls and network protocols, for example) and
other things that are really outside the scope of numerical computing
but which are nice to have.  Octave does include some support for
things like this, but it is a lot of work to maintain.  If I add
support for things like sockets, it seems that I am reinventing the
wheel.  I'd prefer to leave those details up to other hackers so that
I could focus on numerical tools instead.

Is anyone here interested in such a project?  Comments and discussion
would be most welcome.



-- | Thanking you in advance.  This sounds as if the   | writer meant, "It will not be worth my while to
                        | write to you again."        -- Strunk and White

reply via email to

[Prev in Thread] Current Thread [Next in Thread]