<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0">
  <channel>
    <title>MaplePrimes - comments on Post, Axiom vs Maple</title>
    <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple</link>
    <language>en-us</language>
    <copyright>2026 Maplesoft, A Division of Waterloo Maple Inc.</copyright>
    <generator>Maplesoft Document System</generator>
    <lastBuildDate>Wed, 10 Jun 2026 22:18:15 GMT</lastBuildDate>
    <pubDate>Wed, 10 Jun 2026 22:18:15 GMT</pubDate>
    <itunes:subtitle />
    <itunes:summary />
    <description>The latest comments added to the Post, Axiom vs Maple</description>
    <image>
      <url>http://www.mapleprimes.com/images/mapleprimeswhite.jpg</url>
      <title>MaplePrimes - comments on Post, Axiom vs Maple</title>
      <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple</link>
    </image>
    <item>
      <title>Will reply</title>
      <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple?ref=Feed:MaplePrimes:Axiom vs Maple:Comments#comment63886</link>
      <itunes:summary>&lt;p&gt;I have seen this, and I will post something real -- later.&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Axiom vs Maple</description>
      <guid>63886</guid>
      <pubDate>Wed, 26 Aug 2009 18:27:13 Z</pubDate>
      <itunes:author>JacquesC</itunes:author>
      <author>JacquesC</author>
    </item>
    <item>
      <title>Comparative review</title>
      <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple?ref=Feed:MaplePrimes:Axiom vs Maple:Comments#comment63887</link>
      <itunes:summary>&lt;p&gt;I don't have such a comparative review, but as far design ideas for future development,&lt;a href="http://www.cas.mcmaster.ca/~carette/publications/JLM_May29_09.pdf"&gt; I have plenty&lt;/a&gt;.&amp;nbsp; And they are based on my knowledge of the history of CASes.&amp;nbsp; I have 2 Master's students polishing their (defended, accepted) theses who have worked on implementing parts of that, I should be able to post a link to their work soon.&lt;/p&gt;
&lt;p&gt;As far as weak/strong types go, with so many years of experience behind us, the answer is turns out to be rather simple: strong types work realy well when you know what you're doing (i.e. there is strong theory underpinning your work), and are a huge hindrance when you don't.&amp;nbsp; In practice, this means that logic, algebra and functional programming can all be strongly typed, but analysis, geometry and imperative programming can't (yet).&amp;nbsp; Don't get me wrong: the abstract theory of analysis, geometry and even imperative programming are well established; the gap is that the theory of 'computation' over specific objects isn't.&amp;nbsp; In other words, Calculus is well-founded, but doing calculus-like computations on representations of functions (i.e. expressions) isn't.&amp;nbsp; There is no adequante 'denotational semantics' for calculus. &lt;/p&gt;
&lt;p&gt;As far as writing a comprehensive comparison of these two systems, it's a good idea, but not something I&amp;nbsp; am likely to do 'soon'.&amp;nbsp; I have a non-trivial backlog of work that I've done that I still have to write up properly, and so I have tried quite hard to not start too many new projects before a few of the old ones are written up.&lt;/p&gt;
&lt;p&gt;Thanks for the reminder about types and properties.&amp;nbsp; It's triggered a link in my head with stuff I am currently looking at.&amp;nbsp; My colleague Bill Farmer coined some good terminology to do with partial functions: they have an 'apparent domain' as well as an 'effective domain'.&amp;nbsp; When you say, for example, that the domain of (x:numeric) -&amp;gt; 1/x is 'the reals', you are really describing the apparent domain, since 0 is not in fact in the 'effective domain' (of real-valued functions).&amp;nbsp; But can, fruitfully, use 'type' for the 'apparent domain' and 'property' for 'effective domain'!&amp;nbsp; The principal reason for making a difference between them is that we can thus have a decidable type system but an undecidable property system, and still keep everyone happy.&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Axiom vs Maple</description>
      <guid>63887</guid>
      <pubDate>Thu, 27 Aug 2009 17:52:17 Z</pubDate>
      <itunes:author>JacquesC</itunes:author>
      <author>JacquesC</author>
    </item>
    <item>
      <title>before 30 years</title>
      <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple?ref=Feed:MaplePrimes:Axiom vs Maple:Comments#comment63888</link>
      <itunes:summary>&lt;p&gt;No, I did not mean whether you have a review, or will write it shortly, but just&amp;nbsp; when fit, hopefully before 30 years...&lt;br /&gt;
&lt;br /&gt;
I could catch only part of the material in those slides because of the CS&lt;br /&gt;
jargon, but I was a bit surprised by the historical link Maple -&amp;gt; Sage as I&lt;br /&gt;
had thought that the main influence on Sage came from some other CAS.&lt;br /&gt;
&lt;br /&gt;
The way you put the issue of weak vs strong types sounds a bit funny to me. By&lt;br /&gt;
those terms, in Physics research it is not know what is being done: at&lt;br /&gt;
exploring new ground, most likely, a strong underpinning mathematical theory&lt;br /&gt;
is missing.&lt;br /&gt;
&lt;br /&gt;
And, as Physics deals mainly with analysis and geometry, it sounds that a&lt;br /&gt;
strong types will become, most frequently, a hindrance. Something like the&lt;br /&gt;
less typed the better.&lt;br /&gt;
&lt;br /&gt;
This issue might help also to explain why I find Axiom so hard to understand&lt;br /&gt;
and make something useful with it, as it was developed by (and fits well into)&lt;br /&gt;
minds more familiar with fields like logic or algebra. I.e. &amp;quot;strong typed minds&amp;quot;.&lt;br /&gt;
&lt;br /&gt;
In this regard I have seen that a (qualitative/semiquantitative?) measure of the&lt;br /&gt;
&amp;quot;degree of typing&amp;quot; was sometimes posed, as in these articles (&lt;a href="http://www.tcl.tk/doc/scripting.html#921216"&gt;ref1&lt;/a&gt;, &lt;a href="http://en.wikipedia.org/wiki/Programming_language#Typed_versus_untyped_languages"&gt;ref2&lt;/a&gt;).&lt;br /&gt;
&lt;br /&gt;
And here and there I have seen that CAS were sorted after such a magnitude. E.g. &lt;a href="http://lists.nongnu.org/archive/html/axiom-developer/2005-09/msg00211.html"&gt;this post &lt;/a&gt;suggests the following order:&lt;br /&gt;
&lt;br /&gt;
&lt;b&gt;Maple &amp;lt; Mupad &amp;lt; Axiom&lt;br /&gt;
&lt;br /&gt;
&lt;/b&gt;If this order makes any sense, I wonder where other systems lay. Indeed I&lt;br /&gt;
was a bit surprised at reading in the Wikipedia article &lt;a href="http://en.wikipedia.org/wiki/Comparison_of_programming_languages"&gt;Comparison of programming languages&lt;/a&gt; that Mathematica has a strong&lt;br /&gt;
type strength (and no mention of Maple, by the way).&lt;br /&gt;
&lt;br /&gt;
I cannot get you wrong as. I have no idea of what the abstract theories of&lt;br /&gt;
analysis, geometry and imperative programming are. Most likely, whatever I&lt;br /&gt;
have ever done are computations with specific objects.&lt;br /&gt;
&lt;br /&gt;
I do not understand either when you talk about 'denotational semantics'. If you&lt;br /&gt;
mean something like stated in &lt;a href="http://en.wikipedia.org/wiki/Denotational_semantics"&gt;this article&lt;/a&gt;, I am perplexed. I read:&lt;/p&gt;
&lt;blockquote&gt;&lt;i&gt; Broadly speaking, denotational semantics is concerned with finding mathematical objects that represent what programs do. &lt;/i&gt;&lt;/blockquote&gt;
&lt;p&gt;Al least for a mathematical system like Maple, this issue seems to me&lt;br /&gt;
upside-down. What I want is a computational representation of (some)&lt;br /&gt;
Mathematics (and as faithful as possible). What is the point of inventing a&lt;br /&gt;
mathematical representation of a routine for calculus that outputs&lt;br /&gt;
mathematical nonsense? (like several ones in Maple do).&lt;br /&gt;
&lt;br /&gt;
I guess that what you say about a &amp;quot;decidable type system&amp;quot; is related to these&lt;br /&gt;
two articles (&lt;a href="http://en.wikipedia.org/wiki/Decidability_(logic)"&gt;ref3&lt;/a&gt;, &lt;a href="http://en.wikipedia.org/wiki/List_of_undecidable_problems#Problems_in_analysis"&gt;ref4&lt;/a&gt;). But I do not see why that 'apparent domain' is decidable while the 'effective domain' is not. Is there a proof for that?&lt;/p&gt;
&lt;p&gt;&amp;nbsp;&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Axiom vs Maple</description>
      <guid>63888</guid>
      <pubDate>Sat, 12 Sep 2009 08:48:34 Z</pubDate>
      <itunes:author>jakubi</itunes:author>
      <author>jakubi</author>
    </item>
    <item>
      <title>Various</title>
      <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple?ref=Feed:MaplePrimes:Axiom vs Maple:Comments#comment63889</link>
      <itunes:summary>&lt;p&gt;Take a look at Sage's syntax and its leveraging of Python -- that is very Maple-like.&amp;nbsp; The fundamentals of the language (Python + Sage extensions) are quite close to Maple's, as is the paradigm of using an interpreted language to 'script' a set of fast base functions.&amp;nbsp; While the Sage developers may now be influenced by other systems, their basic system is essentially a copy (at the design level) of Maple, whether they like it or not.&amp;nbsp; Personally, I find this very disappointing, since we've learned a lot about how to build CA software in the last 25 years!&lt;/p&gt;
&lt;p&gt;Current research in parts of Physics does strike me very much as weakly typed.&amp;nbsp; This certainly allows you to experiment a lot more, since you don't need to be concerned with small stuff like &amp;quot;making sense&amp;quot;...&amp;nbsp; &lt;/p&gt;
&lt;p&gt;Over the years, I have seen the benefits of both certainty (through solid foundations) and free-for-all experiments.&amp;nbsp; I am interested in building something which allows both.&amp;nbsp; And, by the way, the only 'solid foundations' systems (as far as I am concerned) that are 'real' are &lt;a href="http://coq.inria.fr/"&gt;Coq &lt;/a&gt;and &lt;a href="http://www.cl.cam.ac.uk/research/hvg/Isabelle/"&gt;Isabelle&lt;/a&gt;; there are a number of smaller systems with solid foundations, but their libraries are too small to be interesting.&amp;nbsp; Of course, both those systems are notoriously hard to use as well as being quite slow for doing computations.&lt;/p&gt;
&lt;p&gt;The &lt;a href="http://www.tcl.tk/doc/scripting.html#921216"&gt;degree of typing&lt;/a&gt; picture you refer to is quite good.&amp;nbsp; To be more precise, at 'static' typing, which means typing at 'compile time'.&amp;nbsp; The languages I like these days (Haskell and O'Caml) would fit best in the extreme upper right corner (although, to be fair, &lt;a href="http://wiki.portal.chalmers.se/agda/"&gt;Agda 2&lt;/a&gt; would be even further out).&amp;nbsp; Maple would fit right in between Tcl/Perl and VB, fairly high up [not always a good thing].&amp;nbsp; That Mupad is more typed than Maple and Axiom further still is indeed true.&amp;nbsp; Mathematica is essentially the same as Maple, as is Macsyma on the 'types' scale.&amp;nbsp; The Wikipedia article is very misleading because it does not differentiate between static and dynamic typing!&amp;nbsp; On the dynamic typing scale, Maple is extremely strongly typed -- its type system is Turing-complete!&lt;/p&gt;
&lt;p&gt;As far as denotational semantics is concerned, you are correct, it does seem backwards!&amp;nbsp; But that is the fundamental issue with symbolic computation -- it is all about &lt;a href="http://en.wikipedia.org/wiki/Intensional_statement"&gt;intensional statements&lt;/a&gt; being interpreted as if they were actually &lt;a href="http://en.wikipedia.org/wiki/Extension_(semantics)"&gt;extensional&lt;/a&gt;.&amp;nbsp; People use Maple as if it were about actual mathematical objects, while what Maple really does is 'symbol shuffling'.&amp;nbsp; You need strong reflection theorems to show that these coincide.&amp;nbsp; And we know that these indeed coincide for first-order logic and algebra, and these theorems are 'unknown' for analysis and geometry (even though lots of counter-examples are well-known to naive reflection theorems).&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Axiom vs Maple</description>
      <guid>63889</guid>
      <pubDate>Tue, 15 Sep 2009 05:51:03 Z</pubDate>
      <itunes:author>JacquesC</itunes:author>
      <author>JacquesC</author>
    </item>
    <item>
      <title>degree of typing</title>
      <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple?ref=Feed:MaplePrimes:Axiom vs Maple:Comments#comment63890</link>
      <itunes:summary>&lt;p&gt;This phrase &amp;quot;&lt;i&gt;'static' typing, which means typing at 'compile time&lt;/i&gt;'&amp;quot; makes me wonder how does this concept apply to Maple non-compiled usage.  I see also &lt;a href="http://en.wikipedia.org/wiki/Type_system#Static_typing"&gt;this sentence&lt;/a&gt;:&lt;/p&gt;
&lt;blockquote&gt;&lt;i&gt; In static typing, types are associated with variables not values. &lt;/i&gt;&lt;/blockquote&gt;
&lt;p&gt;As I am not aware of any documentation on this subject, some guesses follow, by interpretation of these statements.&lt;/p&gt;
&lt;p&gt;The kernel routines are compiled, and &lt;b&gt;?type&lt;/b&gt; states:&lt;/p&gt;
&lt;blockquote&gt;&lt;i&gt; The simplest types are the surface types. These are generally defined in the Maple kernel, and represent superficial or top-level properties of expressions. &lt;/i&gt;&lt;/blockquote&gt;
&lt;p&gt;and  &lt;b&gt;?type/surface&lt;/b&gt; states:&lt;/p&gt;
&lt;blockquote&gt;&lt;i&gt; Most of the system types are surface types since these are encoded in the top node of the expression tree. &lt;/i&gt;&lt;i&gt;Thus   &lt;br /&gt;
type({ .. }, set);  &lt;/i&gt;&lt;br /&gt;
&lt;i&gt;type([a] + [b,c], algebraic);  &lt;br /&gt;
Both return true regardless of the types of the components of the set in the first case, and regardless of the types of the terms of the sum in the second. &lt;/i&gt;&lt;/blockquote&gt;
&lt;p&gt;So, it sounds like surface types are static.&lt;/p&gt;
&lt;p&gt;And may be that this concept of static types could be stretched to some types defined in the standard library. E.g. container types like &lt;b&gt;type/Matrix&lt;/b&gt;, independent of the values asigned to the objects they contain.&lt;/p&gt;
&lt;p&gt;Now, names are not declared a static type, and their types will depend on what was assigned to them. However, protected names, in particular system ones, have a fixed value as long as the protection holds. Can their types also be labeled as static?&lt;/p&gt;
&lt;p&gt;So, something like the rest would be purely dynamic types. But I do not understand what do you mean by the statement that their system is Turing-complete. Something like a universal Turing machine can be simulated by Maple type routines alone?&lt;/p&gt;
&lt;p&gt;And I wonder about the actual comparison method that allows saying that A is more strongly typed than B.&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Axiom vs Maple</description>
      <guid>63890</guid>
      <pubDate>Tue, 29 Sep 2009 04:34:03 Z</pubDate>
      <itunes:author>jakubi</itunes:author>
      <author>jakubi</author>
    </item>
    <item>
      <title>sidebar</title>
      <link>http://www.mapleprimes.com/posts/36818-Axiom-Vs-Maple?ref=Feed:MaplePrimes:Axiom vs Maple:Comments#comment63891</link>
      <itunes:summary>&lt;p&gt;Where you mention the &amp;quot;container&amp;quot; type 'Matrix', you might mean 'rtable' (which, unlike 'Matrix', is in the kernel as a constructor). Consider,&lt;/p&gt;
&lt;pre&gt;
&amp;gt; b := Array(1..2,1..2,[[1,2],[3,4]]);
                                      [1    2]
                                 b := [      ]
                                      [3    4]
 
&amp;gt; b.b; # elementwise
                                   [1     4]
                                   [       ]
                                   [9    16]
 
&amp;gt; rtable_options(b,subtype='Matrix'); # change its type
&amp;gt; b.b;
                                  [ 7    10]
                                  [        ]
                                  [15    22]
 
&amp;gt; rtable_options(b,subtype='Array');
&amp;gt; b.b;
                                   [1     4]
                                   [       ]
                                   [9    16]
&lt;/pre&gt;
&lt;p&gt;acer&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Axiom vs Maple</description>
      <guid>63891</guid>
      <pubDate>Tue, 29 Sep 2009 17:55:56 Z</pubDate>
      <itunes:author>acer</itunes:author>
      <author>acer</author>
    </item>
  </channel>
</rss>