Re: [Axiom-developer] domains with parameters versus Python classes

[Gabriel Dos Reis]

"Bill Page" <address@hidden> writes:

| Quoting Gabriel Dos Reis <address@hidden>:
| 
| > ...
| > Anyway, I find the idea of luring Python developers into Axiom by
| > showing them how you can write Spad/Aldor programs in Python
| > and vice versa very, let say, curious.
| >
| 
| I suppose by "very, let say, curious" you mean something like
| "crazy", "silly", "doubtful", "waste of time", etc. ?

"waste of time" and "doubtful".

| I am not sure why you should feel this way. Do you think that
| there is no hope that proponents of Python will ever find any
| advantage in static typing?

First I don't think you're going to gain much in entering the debate
"static typing" when you go to the scripting language community.
There are reasons why scripting languages are so popular.

Second, I don't believe in intrinsic merits of programming languages.
I believe in their effectiveness at letting people *solve problems*, 
express their ideas in natural ways, programming techniques and scalability.


Showing how non-trivial problems are simply and elegantly solved by
given tools is much more convincing and productive than showing
transliteration of a program in different languages.  What is going
to attract people to Axiom is its effectiveness at solving non-trivial
programs, and how the techniques used scale.


| Certainly programming in Python
| seems (at least initially) much easier and faster than in Aldor
| because there is no need to specify types.  

And in many cases, that is just sufficient to solve the problem at hand.

| Specifying correct
| types requires extra discipline and analysis at the start of
| a project.

Yes, but if the problem to be solved does not require scalable
techniques, why bother with extra straight jackets?

|  Similarly, ignoring types until run-time testing can
| (in principle) lead to requiring more time in testing and
| debugging in the last stage of a project. 

Yes, but using types is not a guarantee of absence of bugs.

| There was a lot of
| discussion of this by Python users a few years ago and some
| from of static typing is apparently scheduled to be part of
| Python 3.

I'm very well aware of those discussions, not only in the Python
community, but also in various other scripting language communities. 

| As Axiom users we have an additional reason to be concerned
| with types upfront that has to do with mathematical rigour.

Mostly because we have to come up with techniques that *scale*, and we
are attacking *non-trivial problems at very abstract level*.
Consequently, we need to pin point our thinking.  Types just happen
to be very useful tools for that.  Note that, that in itself does not
mean we must use explicit typing -- we may very well rely on
sufficiently advanced type inference mechanisms -- but yes, explicit
type annotations do make life easier.

| Not only do we want the program to be correct but we also
| want it to accurately reflect or represent the formal structure
| of the matematical objects that we are manipulating.

Note that it is possible to write correct programs without explicit
type annotation.  The issue relates to scale, difficulty, and
generality of the problems and solutions.

| On the other hand, showing Axiom programmers that in
| some ways Spad and Aldor are not so ancient and unique
| might also be a good thing.

I don't understand why that is an important factor.  There are very
few programming languages that have invented anything new in the last
decade or so.  The majority of them just copy over from existing languages
and add some improvements.  The idea that Axiom and Spad
programmers should feel like their language is ancient or unique
suggests that there is a problem with Axiom and Spad users who might
be leaving in a black hole, but I don't believe the solution to that
problem is what I've seen in this thread.

-- Gaby