MathGroup Archive 2013

[Date Index] [Thread Index] [Author Index]

Search the Archive

Re: Mathematica and Lisp

  • To: mathgroup at
  • Subject: [mg129471] Re: Mathematica and Lisp
  • From: Murray Eisenberg <murray at>
  • Date: Wed, 16 Jan 2013 01:41:03 -0500 (EST)
  • Delivered-to:
  • Delivered-to:
  • Delivered-to:
  • Delivered-to:
  • References: <kcqkv4$lq5$> <kct7fj$sgo$> <kd03ej$6dl$> <>

On Jan 14, 2013, at 11:31 PM, David Bailey <dave at> wrote:

>  I do tend to agree that teaching Mathematica as a first programming
> language, would be a bad idea, because so much happens behind the scene
> - for example the way in which multiple definitions for a function get
> reordered to improve efficiency. I would imagine that some students
> would get a hazy idea of what the were asking the computer to do, or how
> expensive it might be.

It all depends on just what you want somebody to accomplish when learning his/her first programming language.

I've thought about that a lot over the some 30 years that I taught FORTRAN, Pascal, APL, J, and Mathematica in university math courses. (My very first programming language was Assembly for a Univac I, followed shortly by octal-coded machine instructions for a paper-tape input computer,  and then FORTRAN II  -- all while I was an undergraduate. A decade later, BASIC, APL, Pascal; subsequently, J and Mathematica. Even later, a smattering of C, Perl, Python, Java. I've even dabbled a tiny bit with Forth and Snobol.)

So what is essential for a first exposure to programming? To me, the essentials are:

(0) Understanding carefully what the problem is, including what is given and what is to be found.

(1) Identifying the objects (data) and what is to be done with them (operations, functions, procedures).

(2) Breaking up a larger problem into its constituent parts.

(3) Isolating the big ideas from the smaller technical points.

(4) Expressing things within the constraints of a precise syntax.

(5) Suitably modularizing the code in accordance with (2) and (3).

(6) Making the code readable through judicious choice of names along with sufficient but non-redundant comments.

(7) Making the code maintainable -- by the original author or others.

(8) Being able to test and debug the code.

(9) For numerical work, understanding and coping with roundoff and other errors due to the limitations of finite precision.

(10) Recognizing when and knowing how to code an operation repetitively -- whether explicitly (iteratively or recursively) or implicitly (functionally).

(11) Recognizing when and knowing how to express conditionals (whether via an explicit If, Which, etc., or instead as is possible in Mathematica, separate definitions of the same function for different cases).

Must the first-language learner get closer what s/he is "asking the computer to do" than might be the case with Mathematica?  If so, how should you reasonably decide how deep to descend? (If you don't know what the ultimate actual binary code is, how could you know what the computer is _actually_ doing?)

My experience, in fact, is that the higher the language level -- such as that possible with Mathematica or APL or J -- then the easier it is to master these essentials.  All too often I have seen students unable to ascend to effective programming with a higher-level language if their minds were rotted by the first exposure being to too low-level a language. (And that is despite my personal learning path that ascended from the ridiculous to the sublime.)

Murray Eisenberg                          murray at
Mathematics & Statistics Dept.      
Lederle Graduate Research Tower           phone 413 549-1020 (H)
University of Massachusetts                     413 545-2838 (W)
710 North Pleasant Street                 fax   413 545-1801
Amherst, MA 01003-9305

  • Prev by Date: Re: neighborhood operations on image
  • Next by Date: Re: TraditionalForm Plot
  • Previous by thread: Re: Mathematica and Lisp
  • Next by thread: Re: Mathematica and Lisp