After visiting one of the Wolfram presentations, I started writing code for my number theory research project in Mathematica because I found it to be faster than Sage. I downloaded Workbench and Mathematica, watched the video tutorials on the Wolfram website and read the tutorials in the manual. Then I started coding. After being at it for a week, I find the whole experience to be extremely clumsy as I can not figure out any reasonable workflow. What I do now is this:

I open Workbench which in turn starts Mathematica notebook. I write a procedure spread over multiple cells in the notebook. When I am happy with the result, I copy the code into the workbench .m file where I make it into a function. Afterwards, I start using the function in the notebook to do my calculations or to use it in other procedures.

I am very happy with the control I have over each step in the notebook and coding in workbench feels quite smooth. What really bugs me is the transition between the two. I just can not figure out how to achieve the smooth workflow I am used from IDEs like IntelijIdea in Workbench.

Truth is, when I was downloading Workbench, I was expecting it to replace the notebook environment of Mathematica with more serious IDE. Yet it just launches Mathematica and the notebook each time I run the project anyway.

So my question is this: What is the proper way to use Workbench to write code? Or is it just my inexperience that makes me think I am doing something wrong? The closest question I found was this: Working in a team in Workbench which talks mainly about version control (which I wanna look at in the next step as git does not seem to cut it). Links to articles or tutorials describing proper workflow in Workbench would be much appreciated as well.

  • 1
    $\begingroup$ In my view, the Workbench is no replacement at all for the notebook interface. I couldn't live without the notebook interface and use it 90% of the time. I only use the Workbench (or alternatives to it) when developing a nice package with the aim to make it complete and re-usable. I think many people who come from other systems, such as Python, don't immediately realize how to use a notebook environment efficiently. In Python, you will often write a program first, then run it, then modify it, run it again, etc. The nature of the language forces you to do this. ... $\endgroup$
    – Szabolcs
    Nov 18, 2013 at 22:45
  • $\begingroup$ ... (Python is a general purpose language not tailored for interactive work, and this shows when comparing a Python-based notebook to a Mathematica based one.) Mathematica is tailored for interactive use, where you write only a small amount of code at a time to get a result, and expand it incrementally. Most of the Mathematica code I type actually gets thrown away. I can afford to do this because (being fluent in Mathematica) I can easily construct very short and easy to type snippets that do exactly what I need at the moment. During a typical session, I never write a substantial ... $\endgroup$
    – Szabolcs
    Nov 18, 2013 at 22:48
  • 3
    $\begingroup$ @Szabolcs As it happens, I am currently half-way through transforming the FrontEnd into something much closer to the look and feel of the traditional IDE like Workbench. There is still a ton of work to be done, but I am very close to the point where I can already use this stuff for all my further developments. I've had several unsuccessful attempts in the past, because I tried to use IputField and other widgets to build the code editors etc. Now I am using notebooks themselves, and so far it has worked great. $\endgroup$ Nov 18, 2013 at 23:12
  • 3
    $\begingroup$ Simplifying things quite a lot, the WB is for extensive code development, and the M f/e is for interactivity. If the focus of your work is M code, use the WB. You have much better refactoring tools (debugger, profiler, more advanced syntax highlighting, code completion, third-party plug-ins, such as vim, integration with thousands of other Eclipse plug-ins, etc.). If your focus is interactivity, trial-and-error, exploration, experimentation, use the M f/e. Generally, extensive M code is better developed in the WB, but explorations are better done in the f/e, but everyone's mileage varies. $\endgroup$ Nov 18, 2013 at 23:15
  • 1
    $\begingroup$ @BoZenKhaa But you have seen the IntelliJIDEA plugin and the thread on SE and our chatroom for it, right? $\endgroup$
    – halirutan
    Nov 18, 2013 at 23:44

1 Answer 1


I'll try to answer this as objectively as possible, but note that this answer is shaped by my experiences, so there is a certain subjective flavour to it.

Before you try to figure out a workflow for a non-interactive IDE for Mathematica such as the WorkBench/vim/IntelliJ/Eclipse (henceforth, IDE) and the Mathematica notebook (NB), you should evaluate and determine if your project/package really needs the IDE.

As a simple example:

  • Are you designing something small and quick?
  • Are you primarily finding your way through the project/topic by trial and error/exploration?
  • Is your work heavy on graphics/interactive features?
  • Does it require a styled notebook for it to work?
  • Are you a beginner in Mathematica?

If you answered yes to any of the above, then you're better off working with an NB than an IDE. A typical IDE is not really suited for these (no interactivity, no graphics, cannot display notebook styles, requires you to create a new project file and folder, etc.) and is geared towards a different audience.

As you've already experienced, these IDEs do not (yet) offer you the convenience of the kernel and interactive evaluations. That means that you, the programmer, should be familiar enough with Mathematica to know the syntax well, be reasonably well versed in the documentation (at least for the basic functions), have a decent grip on operator precedences, be familiar with the scoping rules, levels, etc. Fluency in the language will enable you to continue developing your package without having to stop every second line to cross-check the output of your code (especially the trivial parts) by evaluating it in the kernel. Of course, you should extensively unit test everything you write, but it's good to be able to write freely initially.

Once you start writing medium-large size packages, you'll realize that a good deal of time is spent on the organization and design of the package, in addition to the implementation details. Having a good code structure and organization is important to minimizing the amount of code-reuse and simplifying future maintenance and extensions. An IDE will help you in getting most of this mundane stuff out of the way. The debugging, profiling, refactoring and deploying tools provided by the IDE will greatly help you in streamlining your code and your workflow, and you'll use the NB mostly to test/develop the implementation details, which can then be incorporated back into the package when complete. Again, the IDE can help you here in writing unit tests for the different functions in your package.

Most IDEs also provide good version control features and support most of the common VCS tools. Package .m files are generally easier to version and share (in teams) than a notebook since they're free of metadata and other front-end box stuff, unlike notebooks.

If your project has no use for any of these features or if you aren't able to utilize them, then it would be overkill to use an IDE.

So my point really is that your IDE + NB workflow is not all that atypical for a Mathematica programmer. However, your project should have the right requirements and you should be sufficiently fluent in the language in order to be able to use them harmoniously,

  • 3
    $\begingroup$ Good points, +1. Although, I hope to prove some time soon that management of large code bases and interactivity are not mutually exclusive. We have no idea how much we actually are constrained by the pre-defined dynamics of windows in the editor, and stuff that can and can not be done in standard IDEs. $\endgroup$ Nov 19, 2013 at 2:16
  • $\begingroup$ Thank you for your answer! However I find myself in both categories you mention. I am a beginner - check, i am just messing around exploring - check. But my program is also very heavy on CPU and memory, and from what I understand the profiler is included in WB, not M. I would also like to do version control which does not seem to be very useful in M with all the mess the code is enveloped in. I think will look at the Idea plugin mentioned above to see whether it suits my needs. $\endgroup$
    – BoZenKhaa
    Nov 19, 2013 at 7:52
  • 1
    $\begingroup$ @BoZenKhaa It's not just the WB that has the profiler... see this answer for profiling within Mathematica. Also, you might find this answer of mine useful if you're planning on using git for VCS. $\endgroup$
    – rm -rf
    Nov 19, 2013 at 8:04

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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