MathGroup Archive 2009

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

Search the Archive

New free introductory book on Mathematica programming, and a few

  • To: mathgroup at
  • Subject: [mg96352] New free introductory book on Mathematica programming, and a few
  • From: Leonid Shifrin <lshifr at>
  • Date: Thu, 12 Feb 2009 06:35:34 -0500 (EST)

Dear Group,

This is my first post here, although I have been
a long-term Mathematica user. My field is (more correctly,
was until recently) Theoretical and Mathematical Physics.

I have been using Mathematica for about 12 years now,
but only the last 4 as a programmer. Being a Mathematica
enthusiast, I have written an introductory book (well, a
first part of it) on Mathematica programming based on my
own experiences and my compilation of existing literature,
as an expansion of notes-to-self. The motivation was to
minimize frustration of learning Mathematica programming for
someone like myself 4 years ago.

My experience is that, for a beginner, it is easiest to learn
Mathematica (programming) when it is illustrated with many simple
examples and is as much separated from any field-specific
application as possible. This is what I tried to do in the

What I had in mind was a pure programming book about Mathematica
language, with no reference to any specific field-related
functionality, with lots of examples being small but complete
projects, less comprehensive than Mathematica book but containing more
substantial programs, easier to read than Roman Maeder's books
(but by no means a substitute), more applied than David Wagner's
(apart from the fact that it is out of print), going a little deeper into
the language core and being somewhat more pragmatic than
Paul Wellin et al (please don't get me wrong - these are all excellent
books), and centered around functional programming layer, main
higher-order functions, idiomatic Mathematica programming and

An ideal reader for it would be a person who has some Mathematica
experience as a user, needs to write programs more substantial
than a few one-liners, and wants to understand the logic of the
language and ways to program idiomatically, minimize programming
effort and maximize program's efficiency. Parts of the book
(chapters 1-4) can also be useful for more occasional Mathematica
 users, and the last chapter may be of some interest to more
experienced users as well.

I much hope that the book will be not completely useless  and
that I will get some feedback which will help me improve it.  If you think
that some material is described inaccurately, or missing, or unnecessary,
or whatever, please let me know!

The book is available for free from my web site,


and is published under Creative Commons Non-commercial
share-alike License. It is possible to read it online or
download a pdf version.

Apart from the book, I have made several tools that I use
 myself and that I believe could be of interest to
some Mathematica users. I plan to sumbit them to MathSource
soon, but will appreciate any feedback even before that,
while they are in "alpha".

All packages are accompanied by Mathematica notebooks with
numerous examples of use and explanations of all package's
features. They have been all tested with v.5.2 and 6.0,
although perhaps my test suits were too thin. The following
packages are currently freely available  from the same web site,


- Cache

    Creates a cached version of a given function and
    fetches results of frequent function calls  from cache
    of a fixed user-defined size. Slower than f[x_]:=f[x]=...
    idiom, but you control the size of DownValues list. Can
    be useful for functions which are at least minimally
    computationally demanding, in unattended computations.

- UnsortedOperations

    Reasonably fast functions to do various manipulations
    with several lists without sorting, such as mapping
    a function on elements of one list being members of
    another one, unsorted Union, Intersection, Complement,
    etc. This package is an expansion of the last case
    study in the last chapter of the book.

- AttributesOfPureFunctions

    Produces new pure functions at run-time, with the
    desired sets of attributes but otherwise the same as
    the original ones. Can also "wrap" the "normal"
    (DownValue-based) function into a pure function wrapper,
    with the pure function sharing with the original all
    Attributes that make sense for pure functions.

- CheckOptions

    For any user-defined (or modified) DownValue-based
    option-taking function, which uses the ___?OptionQ to
    declare options, adds new definitions that check
    options for validity (not just the option name, but
    also the option's rhs) and can execute arbitrary user-
    defined code upon receiving inappropriate option(s) (such
    as returning $Failed, Throw-ing an exception, etc).
    The limitations are discussed in :Discussion:
    section of the package documentation.

- PackageOptionChecks

    Elevates the functionality of  CheckOptions to the level
    of the package(context), while retains the control on
    the level of individual functions as well. Adds an
    easy-to use interface to "protect" package's functions
    from inappropriate options. Can work from within the
    package of interest, or "externally" (in the latter case
    no code modifications for the package itself are needed).
    Can be also used for Global` context during interactive
    development (before putting functions into a package).
    Essentially, allows to "meta-program" the package by
    specifying the response actions for each function after
    (and independently) of the main function's code, and
    gives the user external control over this responding
    behavior. Can also be used as a debugging tool.
    Limitations are discussed in the :Discussion: section of
    the package documentation.

- PackageManipulations

    Allows to dynamically reload, clear or remove the
    package's context in a way consistent with general
    package mechanics in Mathematica. Useful for interactive
    package development, especially for larger projects with
    many inter-dependent packages. Dynamic re-loader tracks
    escaping symbols and (optionally) can automatically
    resolve possible shadowing problems occuring before or
    during re-loading.

- PackageSymbolsDependencies

    For a given package/context, answers the following

    1. Do there exist symbols in other contexts that
    depend on symbols in a given one through some global
    properties (DownValues etc)
    2. If so, what they are
    3. For a given arbitrary Mathematica expression, what
    are the symbols used to build it, and their contexts
    4. Whether or not a given symbol is shadowed

    The package is highly customizable, with its efficiency
    depending mainly on how much we know about the set of
    possibly dependent symbols. It can be used to analyze
    inter-context dependencies in larger projects, and to
    discover/monitor modifications that a given package
    induces in other contexts (including overloading system
    functions). This is also a good practical example of
    <PackageOptionChecks> in action, since options here are
    protected with PackageOptionChecks.


If you intend to use any of these, I will be happy, but  please read the
disclaimer on my web site. If you find bugs in the packages or in the book,
I will also greatly appreciate if you let me know - please see the
<report_bug> section of my web site.

Everybody thanks a lot for attention,
and Best Regards!

Leonid Shifrin

  • Prev by Date: Re: Shortest Path Problem
  • Next by Date: Re: Re: Re: testing if a point is
  • Previous by thread: Problem Solved! - FW: Reposted, Reformatted Re: "mapping" functions over lists, again
  • Next by thread: Re: New free introductory book on Mathematica programming,