I consider myself a pretty good Mathematica programmer, but I'm always looking out for ways to either improve my way of doing things in Mathematica, or to see if there's something nifty that I haven't encountered yet. Where (books, websites, etc.) do I look for examples of good (best?) practices of Mathematica programming?


19 Answers 19


Here's a collection of resources that I started on Mathgroup (a collection of Mathematica learning resources) and updated here at Stack Overflow. As this site is dedicated to Mathematica it makes more sense to maintain it here. This represents a huge amount of information; of course it's not exhaustive so feel free to improve it! Also, don't hesitate to share it and suggest other interesting links! Remember, you can always search the online Documentation Center of Mathematica, that is identical to the built-in help of the latest software version.

Links to more advanced aspects of the program that you can start to appreciate once you understand the basics are provided in separate answers (below) as this post became too large.


Basic advices for people new to Mathematica

Functional style

Avoid iterative programming using loops like For or Do, use instead functional programming functions Map, Scan, MapThread, Fold, FoldList, ... and pure functions. This makes the code cleaner and faster.

Transpose and dimensions

  • Something not easy to guess alone at the beginning: if you have x={1,2} and y={3,4}, doing Transpose[{x,y}] or {x,y}ESC tr ESC in the front end will produce {{1,3},{2,4}} (format compatible with ListPlot). This animation helps understand why.

  • You can also use the second argument of Transpose to reorder the indices of a multidimensional list.

  • Don't forget to regularly control the output of the lists you generate using Dimensions.

Get familiar with shorthand syntax (@, &, ##, /@, /., etc.)

Programming easily

  • Getting help: Execute ?Map for example for a short description of a function, or press F1 on a function name for more details and examples about it. You can solve many problems by adapting examples to your needs.

  • Auto-completion: Start typing the name of a function and (in Mathematica 9+) select from the pop-up auto-completion menu, or press Ctrl+k to get a list of functions which names start with what has already been entered. Once the name of the function is written completely press Ctrl+Shift+k (on Mac, Cmd+k) to get a list of its arguments.

  • Function templates: In Mathematica 9, after typing a function name, press Ctrl+Shift+k (on Mac, Cmd+Shift+k) and click on the desired form from the pop-up menu to insert a template with named placeholders for the arguments.

Other useful shortcuts are described in the post Using the Mathematica front-end efficiently for editing notebooks.

  • Use palettes in the Palettes menu especially when you're beginning.

  • In Mathematica 8, use the natural input capability of Wolfram Alpha, for example type "= graph 2 x + 1 between 0 and 3" without the quotes and see the command associated with the result.




Wolfram Websites





Other related sites

Virtual conferences

Mathematica one-liner competition

Wolfram technology conferences

  • 69
    $\begingroup$ Apparently, this is the most edited post by a single person across all of the SE network. You've really done a remarkable job at maintaining it! $\endgroup$
    – rm -rf
    Commented Jul 17, 2012 at 19:36
  • 13
    $\begingroup$ Thanks, maintaining this list is a good way also to keep track of interesting posts on this site that summarize well some aspects of Mathematica. $\endgroup$
    – faysou
    Commented Jul 18, 2012 at 11:50
  • $\begingroup$ Is there a way to download the videos from wolfram.com/broadcast? $\endgroup$
    – a06e
    Commented Oct 18, 2012 at 14:37
  • 1
    $\begingroup$ @becko it's not too hard - like downloading YouTube videos, there are various ways. On Mac Safari, I set the user-agent to iPad before going to the page, then Download Linked File: this gets the mp4 download link. (No Flash for me!) $\endgroup$
    – cormullion
    Commented Nov 7, 2012 at 15:22
  • $\begingroup$ @cormullion Got any tricks that work on Windows? I usually download videos from Youtube using a little program called Free Youtube Download. But that doesn't work on wolfram.com/broadcast (except for a few videos at wolfram.com/broadcast that are actually hosted on Youtube). $\endgroup$
    – a06e
    Commented Nov 7, 2012 at 18:15

My original post above became too big so I'm splitting it into two posts. The tips and tricks section that I used to keep track of interesting new posts mostly on this site was big so here it is.

Note the tags at the end of each question on this site in order to read related questions.

I'm further dividing this post. See my third answer on Advanced evaluation, patterns, and neat algorithms below.

Tips and tricks

Top posts

General tricks

Tips for writing faster code

Reap and Sow


Using links to other languages

Packed arrays


Data Structures


Traversal of an expression


Optional Values

Accessing data in different ways


Rules and replacement (the backbone of Mathematica, more advanced)

Getting ideas from Lisp


Undocumented features

IDEs and packages

Mathematica functions and environment

  • 9
    $\begingroup$ Now this is really useful, big +1. The better we categorize all these resources, the more effective this page will be. $\endgroup$ Commented Jul 25, 2012 at 10:55
  • 5
    $\begingroup$ This could be the Table of Contents of Mathematica.SE. $\endgroup$ Commented Mar 11, 2013 at 16:54
  • 2
    $\begingroup$ This is such a fabulous resource, thank you for taking the time to compile it. $\endgroup$ Commented Jun 3, 2013 at 8:11
  • $\begingroup$ Hi, @faysou, I'd like to see "Data structures and efficient algorithms, from Daniel Lichtblau", but this resources is not available anymore. Do you have a copy? $\endgroup$
    – matheorem
    Commented Aug 31, 2016 at 4:32
  • $\begingroup$ @matheorem no I don't, unfortunately. $\endgroup$
    – faysou
    Commented Nov 25, 2017 at 21:32

Third part of my collection of links, dedicated to advanced evaluation, pattern matching and neat algorithms (which is quite arbitrary but contains a lot of interesting Q&As in my opinion).

Advanced evaluation of expressions

  • Non standard evaluation allows to work on the symbols of an expression before they get evaluated.

    Here's how I represent myself Mathematica's evaluation: consider a function/tree f[a,b]. Without any particular attribute for f the leafs/arguments will be evaluated before the parent f. With f having a HoldAll attribute you don't evaluate the leafs but go directly in the evaluation of f. a and b will be evaluated as soon as they are used in a function that doesn't hold again their evaluation. For example

     f[a_,b_]:= a Hold[b]; 
     f[2^2,2^2] (* returns 4 Hold[4] *)
     SetAttributes[f, HoldAll];  
     f[2^2,2^2] (* returns 4 Hold[2^2] *)

    You can also see with the above example that SetDelayed (:=) acts like a With, ie it can insert a value inside a held expression.

Preventing evaluation of Mathematica expressions
Hold any argument
How can I hold UpValues but evaluate other expressions?
Symbolic computations with already assigned variables
How to pass a symbol name to a function with any of the Hold attributes?
Pure function with attributes of arbitrary number of arguments: Is it possible?

Enforcing correct variable bindings and avoiding renamings for conflicting variables in nested scoping constructs
StringReplace, ReplaceAll and Rule interact in a bizarre way

Programmatic formatting for Mathematica code - possible?

Pattern matching

A pattern is a way to quickly describe the structure of expressions and do computations on them, using /. or Cases for example.

Neat algorithms

  • 1
    $\begingroup$ That's incredible! Thanks for keeping up a great work, this is very useful for all of us, much appreciated. $\endgroup$ Commented Sep 17, 2013 at 13:42
  • $\begingroup$ You're welcome, you're the hero of many of these posts. $\endgroup$
    – faysou
    Commented Sep 17, 2013 at 14:52
  • 1
    $\begingroup$ @Leonid I've collected some of your answers where you use a parsing approach, if there are other such posts could you please add them to the list ? $\endgroup$
    – faysou
    Commented Jan 18, 2014 at 22:30
  • 2
    $\begingroup$ Thanks. It's good that this technique is now systematically represented here, I think it is an important one. I have added this one, and my answer for the code formatter question (since in a sense formatter is also an expression parser, and in fact a pretty sophisticated one), which are the only ones that comes to mind right now. $\endgroup$ Commented Jan 19, 2014 at 12:56
  • 2
    $\begingroup$ I find the most difficult part of Mathematica is controlling evaluation (because there isn't just a single way to do it), and I think it's very important for the future of Mathematica, where macros (or code for rewriting code) is the horizon. The post above is extremely valuable. $\endgroup$
    – Reb.Cabin
    Commented Dec 27, 2014 at 12:26

I highly recommend examining the included packages under your Mathematica installation directory:





You can also find examples of good practice, framework guidelines, and insider methods in the presentations from various Mathematica conferences. A mere sampling:

1999 Mathematica Developer Conference

2003 Mathematica Developer Conference

2007 Wolfram Technology Conference

Many, many more.


Besides the documentation, which I find very helpful, I also like the following resources:

  • The Wolfram Demonstrations Project is a fantastic resource, where you can draw up previously successful programs and learn some best practices. Their utility has varied, but I've certainly learned a lot by seeing great code in practice.
  • In a similar vein, I also follow the 'Wolfram Blog'. It's not all universally relevant for my own interests, but following it on Twitter is a good way to dip in here and there.
  • Finally, as a new user, I also draw on the Mathematica Cookbook for some nifty examples.

As noted above, however, I normally use the documentation and look through examples of uses, as that's my best way of learning.

  • 1
    $\begingroup$ +1 for the cookbook but I agree with @Nasser on the readability of the demonstrations (plus, doing everything in one giant code block as demonstrations seem to organize things is probably not going to scale very well for anything nontrivial) $\endgroup$
    – acl
    Commented Jan 19, 2012 at 13:26

In my opinion, rules and pattern matching are central to mastering Mathematica. I strongly recommend Demystifying Rules by Nancy Blachman published in The Mathematica Journal, Volume 8, Issue 4, for a solid grounding in this area. It is available on-line at The Mathematica Journal


For neat tips and tricks, there is a daily tip posted to the MathematicaTip twitter page.

  • 1
    $\begingroup$ This is a pretty good resource. It has lots of small, easy to digest snippets. $\endgroup$ Commented Jan 18, 2012 at 4:44

The Mathematica GuideBook by Michael Trott always gives me lots of inspirations. Beside of it (and other places been mentioned above), I like exploring the SystemFiles folder. Some interesting tricks (especially about interface and FrontEnd) are hiding there.

  • $\begingroup$ The SystemFiles suggestion is a good one. Do you have any particular examples to share? $\endgroup$
    – Verbeia
    Commented Jan 18, 2012 at 2:28
  • 1
    $\begingroup$ @Verbeia Some undocumented things can be learned from the system files. such as "SyntaxColoringReasons" for CurrentValue which can be seen in WhyTheColoring.nb (Dynamic[CurrentValue[InputNotebook[], "SyntaxColoringReasons"]]), system fonts classification which can be seen in UnicodeFontMapping.tr, some inappropriate converting when import GBK encoded Chinese text can be corrected by manipulating CP936.m, etc. $\endgroup$
    – Silvia
    Commented Jan 18, 2012 at 11:49

The 'Mathematica GuideBook' series by Michael Trott has tons of good examples that go much further than typical 'toy-examples'. I found it a very valuable and thorough ressource for learning the ins and outs of the Mathematica language.


Nobody's mentioned the packages that come with Mathematica. There's a heap of great coding examples in there, especially the later packages.


Fourth fork of the list of links.



Finance (but not only)





Not strictly a Mathematica blog but Rip’s Applied Mathematics Blog is a very nice resource for advanced Mathematica problem solving. Rip makes regular weekly posts on whatever interests him that week and they usually include some neat implementation in Mathematica.

And another very good reference Mathematica blog by Kris Carlson with interesting methods and examples:

  • 1
    $\begingroup$ If bewildered one should look into examples rip94550.wordpress.com/2012/04/16/… $\endgroup$
    – Artes
    Commented Apr 24, 2012 at 12:03
  • 1
    $\begingroup$ Thanks this blog is very interesting. $\endgroup$
    – faysou
    Commented May 1, 2012 at 14:17
  • $\begingroup$ The author of this blog has passed away late last year. $\endgroup$ Commented Jan 25, 2014 at 14:10

I'm not sure this has already been posted but I found these tutorials really helpful as a beginner. They are problem based (similar to the Euler Problems) and the author takes you through the solutions in a step wise fashion. Hope it helps.



Personal websites


Resources on other languages



Stack Exchange sites

Links to some packages

Packages for preparing publication-quality scientific figures

  • LevelScheme by Mark Caprio (latest version: 3.52, Sep 2011, for Mathematica 6 and higher)
  • Presentations and other packages by David Park (latest version: 25 Aug 2011)
  • A WorkLife Framework by Scientific Arts LLC (extendable and customizable toolset that broadens Mathematica's scope across many aspects of daily work)
  • FeynArts by Thomas Hahn (latest version: 3.7, 27 Mar 2012, package for generation and visualization of Feynman diagrams and amplitudes)
  • Writing and Publishing a Book with Mathematica by Paul R. Wellin (2005, available from the Wolfram Library Archive)

Useful non-free tools for development, deployment, distribution, linking, etc.


Stephen Wolfram: An Elementary introduction to Wolfram Language

Also, this does not belong 100% here but it is an overshelming list of reference to be missed. A Bibliography of Publications about the Mathematica Symbolic Algebra Language

enter image description here


I am not sure if it has already be mentioned.

Adding Object-Oriented Capabilities to Mathematica


I'm a beginner, and I find it interesting to explore the documentation. Some of the commands I've read about have given me interesting ideas for programs. Also, I'm not sure if this has been mentioned, but the Wolfram Demonstrations Project has a bunch of amazing programs you can play with and download the code from.


ApplicationMaker shows how to create packages that look like native functionality, including integration into the Documentation Center.


I have been adding some new content here (mostly following along with the elementary introduction book and doing explorations in machine learning):


These 'live coding' sessions are recorded so you can watch them. They are a little bit different from pre-recorded video tutorials, because there is a chat window where 'live watchers' can ask questions (which you can not do when you watch the recording, of course).


Not the answer you're looking for? Browse other questions tagged or ask your own question.