Message Boards Message Boards

4
|
36036 Views
|
34 Replies
|
26 Total Likes
View groups...
Share
Share this post:
GROUPS:
Mathematica

Stability of Mathematica 10

John McGee, Radford University
Posted 10 years ago

I have been a regular and enthusiastic user of Mathematica since version 3. I am very concerned about the stability of Mathematica 10.0.1. It crashes when attempting spell check. It often hangs and then crashes when using == (access to Wolfram Alpha). It crashes when editing complication 2D expressions, especially of delete is used. Perhaps this is related to the undo feature. Is my installation somehow damaged, or are other users experiencing this type of difficulty? My frustration level has risen to the point that I am seriously considering switching to a competitors software. Mathematica's capabilities and feature set are tremendous, but that is not valuable to me if it crashes frequently. I would really like to know what other users are experiencing.
POSTED BY: John McGee
34 Replies
Sort By:

I had a similar flakey problem and ended up communicating with Mathematica Support who suggested the following:

  1. With Mathematica open, select 'Preferences...' from the 'Edit' menu. Then select the 'Evaluation' tab in the window that pops up.  Try hitting the 'Reset to Defaults' button and see if the computation will work then. 

  2. If the above does not resolve the issue, try resetting Mathematica to its default settings.  For instructions on doing so, please see     http://support.wolfram.com/kb/3274   The first item did nothing to help at the time BUT the second one not only fixed my problem then but recently also another instability problem with using the Graphics -> Drawing Tools. - That's 2 for 2 in correcting instability problems. Only problem is you have to erase your preferences file (save first !) and re-register your product -not a big problem and it is soooo nice to get rid of that instability or buggy behavior.
POSTED BY: Mackenzie Campbell

Well, we have been promised a desktop version 10.0.2 "soon", since October or so. So it will come, well, soon. Like PlayerPro 10, also promised soon, this year, which proves that they are indeed working to fix bugs and have nice new features.

What do you mean by "released"? It still says "BETA" on the programming.wolframcloud.com site. Some things already work very nicely, but, e.g., ListPicker, or uploading an Excel file does not. Also, while JLink works, MathLink and LibraryLink do not work on the cloud, which is unfortunate, but understandable for security reasons. Of course one would want to fix this in a private cloud version. But that version seems to be not available yet, hopefully soon.

Multiple undo is nice (though has been there for a long time for proper .m files in Workbench or IntelliJ or vi), but if this is the cause of crashes I will switch it off immediately once I use more Mathematica 10, which is supposed to be released soon (10.0.2, I mean).
POSTED BY: Rolf Mertig

Perhaps this is a case of too many projects underway at once. I saw Wolfram people using 10.0.2 for their talks at the Wolfram Technology conference in October, so it is not 'vaporware', and there are real fixes to problems. I would have thought that 10.0.2 would have been out already.

Workbench 3 won't be out until 2015 (early), from what I have been told, but I have no information about a version 10 compliant CDF player. David Park, in his discussions on this thread, has convinced me to give workbench another shot, but I cannot share any of my version 10 work with non-Mathematica owners until there is a CDF player that they can use.

From the viewpoint of a user, I think it is time for a semi-major version -- say 10.1.0 -- that would consist of nothing but bug fixes and bringing CDF player, Workbench, etc. into sync with the main product.

I would include in this 'bug fix' release such things as the Cocoa front end for OS X that is way overdue. I am fully cognizant of the technical difficulties, but the Carbon APIs that are in the current front end have been deprecated for at least 5 years. I am sure that there are similar issues for Windows and Linux. This discussion started on the topic of stability, and from all anecdotal information, the OS X version is far more stable than Windows or Linux.

We have not had a '.1' release since version 5.1; they were fairly common before then. While naming versions is somewhat arbitrary, a 0.0.1 update indicates that there are minor changes, or stuff that did not make the cutoff. A '.1' release indicates, to me at least, that significant issues with the product have been rectified without making substantial changes in the program's 'footprint'.

I think that this is exactly what Mathematica needs.
POSTED BY: George Woodrow III

A 10.1 would be great if the company undertook to fix ALL outstanding bugs and introduce no new features.
POSTED BY: Mike Honeychurch
Mathias Breuss
Mathias Breuss
Posted 10 years ago

I am a very young Mathematica user, started with Mathematica 9, using it under Windows 7. I don't have stability issues unless Mathematica tries to connect to the internet and fails because the proxy server is not set properly. Then it seems it is dealing with a wait / timeout behavior that finally forces me to kill Mathematica with the task manager. Beside that I did not experience stability issues.

However, I already reported multiple issues to the Mathematica support. Issues which could be considered minor in general but are critical to me. I have the impression that wolfram does not take these inputs seriously. When contacting the support they usually provide first feedback that the report was received but after that things go silent. Of course no solution is provided eventually.

For a software that costs multiple thousands of € for commercial user that is quite an issue on its own.
POSTED BY: Mathias Breuss

This may be a case where the squeaky wheel gets the oil.

Based on my discussions with the Wolfram engineers, they are aware of problems -- certainly my issues. They do not always get around to fixing them as fast as I like, but multiple contacts could not hurt.

At various times, I have gotten a 'boilerplate' type response from technical support. If this type of response does not meet your needs, you should respond with more information or clarification. I can tell that this strategy will often get a problem before more people, and that has to be a good thing.

It is my belief that a major part of WRI's resources have been allocated to Mathematica on-line and related projects. Now that that project has been launched, I am hopeful that some issues with desktop Mathematica (which should also affect the on-line version) will be addressed.

Perhaps more than most other programs, Mathematica will thrive only if enough people are passionate about the program and its potential. Having been with Mathematica since version 1, I can tell you that the company does care, and eventually, major issues do get addressed (multiple undo, anyone??).
POSTED BY: George Woodrow III

Have not noticed stability problems in V10 on Yosemite and prior to that Mavericks but admittedly did not use it much due to the amount of bugs present and the lack of Player Pro. I am still on V9 95% of the time but want to shift 100% to V10 when these issues are fixed because I like some of the new features. It remains a source of frustration that bugs go unfixed for multiple versions. In the V10 installation I have tried (10.0.1) there are bugs reported in V7, V8 and V9 still present.
POSTED BY: Mike Honeychurch

I know this topic started with frustrating crashes in Mathematica 10. I hope it is all right if I extend it to matters of ease of use in writing technical documents and applications. I think this is another area where WRI has either failed to sufficiently complete the task or veered off course. What WRI has done in terms of basics is so fantastic that the frustration is that it's not easier and more intuitive to put the pieces together in new and more precise ways. I'm not thinking of the more "primitive" routines as being access to low level code such as C++. Neither do I think of them as routines only for advanced users. I think they would be commonly used. And I recognize that there are some really hairy advanced algebraic algorithms that are not going to be broken into usable primitive pieces. Nor is there anything wrong with having high level routines for very common operations such as some common plots - as long as there is an alternative path. The problem comes when a user is encouraged to start with a high level construction and then modify it, usually through options, to a particular form that he may need. Sometimes this leads to a long set of trial and errors, which ultimately fail. This is a serious hurdle to what by rights should be a more common use of Mathematica. And, again, I would like to stress that WRI has created a great set of tools but they can in no way envision all the ways these tools could be assembled to study, investigate and present information.

Here are some examples. (Some of them I have attempted to address in my Presentations Application. All of them come from studying various mathematical topics and writing tutorial notebooks as a method of learning. Trying to design new "presentations" of established material is a good way of learning and can even be 'value added'.)

1) Why isn't doing graphics more like drawing on a piece of paper. If 'everything is an expression' is a central paradigm of the Wolfram Language, then why isn't 'everything is a graphics primitive' a central paradigm of graphics? Why couldn't curves, surfaces, trees, axes, bars, scales and various types of labels also be primitives like Lines, Circles, Points etc. You could directly generate them, operate on them if you wanted and put them where you want. Writing a really nice graphic usually involves a fair amount of detailed specification, with development and reevaluation. You want to be left with a detailed written specification (after all, you may want to add an extra curve, or some other item, or take out something later.) Something like Drawing Tools is not really satisfactory for this.

2) Custom tables are just as important as custom graphics. How many users find it easy to create custom tables? Are they used much at all? The problem here is that much of the specification is done with rather opaque Grid options. Why can't you draw a table like you draw a graphic?

3) Manipulate is the high level routine for dynamic displays. But again it makes many choices for you and is somewhat opaque with much use of options. Most dynamic displays would benefit from well designed placement of graphics, controls, text and digital display of values. The controls might not all be on the top or bottom or together. This is much easier to do directly, and more primitively, with a DynamicModule. You can include routines that calculate dependent dynamic values that may link various parts of the dynamic, and you can use Rows and Columns to lay out the display. Sometimes you might want to have a control as part of a graphic. Although a Control is usually a graphic it can only be inserted into a graphic with Inset. However, a control, such as a Gauge or Slider, comes with unspecified "stuff around it" and it is trial and error to precisely align it with elements of a graphic, and then it is not stable with respect to changes in the ImageSize of the graphic. I did end up designing some graphical sliders. Would it be possible for users to more easily design their own graphical Controls instead of just being given a palette of them to choose from?

4) Matrix reduction and manipulation is another area where more and better primitive routines could be provided. How about all the students who are learning basic methods of combining rows, pivots and things like that? There is a RowReduce routine that has one weakness. Suppose you wanted to confine the operation to a specific block of a matrix? (Don't reduce beyond that block but of course operate on all columns.) You can't do that. You might have a matrix structure with left and right hand sides and not want to extend the reduction into the right hand side.

I'm sure there are many other examples. I would prefer that WRI didn't try to write "convenient" routines for various fields. I don't think they are really good at it. The applicable applications are too many and their proper handling is too detailed. I don't know if they have time for that. What they can do is ferret out the basic operations and routines that are used in putting together mathematics and present them in such a way that it is easy and even intuitive for users. They are very good at the basics (and some of the basics are quite sophisticated). Let users have more control in putting them together.

Ii think the overall WRI documentation is very good. The one weakness might be in the content of some of the Function pages. Sometimes the examples are formalistic without enough practical examples that could be useful to students. It might be helpful if WRI had a mechanism (devoted to the documentation) where users could suggest improvements in a help page and sometimes even provide some practical examples. Over time this could provide a much richer documentation.

George Woodrow commented on Option completion. Presentations does have an OptionFinder feature that was contributed by Thomas Münch and Syd Geraghty. You can click in the head of a routine and then use the OptionFinder to display all the options for that routine. You can paste them in directly and change their values. It also has links to the help pages of all of the options and to the routine itself. I find this very useful.
POSTED BY: David J M Park Jr

I have raised the issue of access to lower-level routines with Wolfram engineers at various times. With Xcode (and I am sure other IDEs), one always has access to the file headers to get detailed information about functionality, and I think that Mathematica or Wolfram Language needs the equivalent. The Wolfram engineers have access to them, because they use them in their own presentations and when answering technical questions. Given that the users of these primitives are likely to be well beyond the novice stage, the level of documentation can be minimal.

Perhaps there could be a developer program that would provide additional documentation and access. I remember that the Wolfram Technology conference started out as the Wolfram Developer's conference. The company was a lot smaller then -- and the Mathematica coder base was much smaller -- and the conference gave you access. I think that this idea can be built upon and formalized.

Even having all possible options show up in the code completion popups (e.g., options for "Appearance") would be useful. A preference could be set to indicate the level of detail the user wanted, so the list of choices would not overwhelm a neophyte.
POSTED BY: George Woodrow III

Mathematica 10 appears to have caused more problems for Windows than for Mac. I considered it bad enough on Windows 7 that I reverted back to Mathematica 9.

I wonder what users think about having multiple Menus on multiple notebooks? It may be connected with the new Undo and at first seems like a good idea in itself. But it has one major problem: it's no longer possible to minimize Mathematica with one click as in previous versions. One might want to do this to temporarily put Mathematica aside and make screen room to work on some other task.

There is another problem with this concerning the use of side windows. Using a side window is useful if you want to present a display that remains in view while scrolling the notebook. There are two principal types of side windows, notebooks and palettes. If you want to minimize Mathematica you now have to minimize all the notebooks and then the palettes are automatically hidden. You can put dynamics and graphical displays in palette windows - except that you can no longer rotate 3D graphics with the mouse. I did submit a bug report and notebook and it was sent to the developers. I hope they fix it in 10.0.2.

Another concern that I have is stability over Mathematica versions. Beyond the use of Mathematica as a super graphical calculator scratchpad, I believe that a natural usage would be the writing of literate notebooks and applications consisting of literate notebooks, packages and documentation. Mathematica has tremendous advantages in this area but I don't know if it's very much exploited. These take much more work than just scratchpad calculations and a lack of long term stability may mitigate against it.

One trend in Mathematica that I find disturbing is the introduction of more "set-piece" high level routines without easy usage or even access to lower level routines. (One example might be graph theory, which combines algebra with graphics. There are many other rough patches, many of them that revolve around graphics.) It is all right to have "set-piece" routines for common things that users do. But they should be built on lower level accessible routines.

Just presenting a "palette" of choices (such as PlotThemes) to users is not sufficient. It vastly underestimates the true power of Mathematica with its active calculation and dynamic controls. You can't just present users with a palette of animated (say) 19th and 20th century graphical presentations. The universe of concepts or data that one might want to present is too large and the possible methods of presentation too great. We have no idea what great new techniques might be invented. Users need easy methods to build these up using primitives. It should be more like writing on a sheet of paper.
POSTED BY: David J M Park Jr
Alexey Popkov
Alexey Popkov
Posted 10 years ago

I wonder what users think about having multiple Menus on multiple notebooks?

What I really like about the new-in-v.10 multiple windows interface is that it provides a workaround for the long-standing bug of empty list of opened Notebooks in the "Window" FrontEnd menu: now the individual Notebooks are also available from the Taskbar and I no longer have to rely on the FrontEnd menu.

Just presenting a "palette" of choices (such as PlotThemes) to users is not sufficient. It vastly underestimates the true power of Mathematica with its active calculation and dynamic controls.

I agree absolutely. The PlotThemes-style of development feels like step backward in the design of the system: it does not expand the possibilities but provides a limited number of hard-coded choices which are already simply outdated in their design (and always will for the obvious reasons!). It is not an expedient direction of development. What I expect in the future versions are new ways to construct graphics from other graphics. In particular I lack vector CropByMask command which would allow to crop a vector object by some vector mask defined, for example, as a Polygone (keeping everything in vectors of course!). I also lack the working FullGraphics function (which starting from version 6 simply does not work in the most of cases). I also feel that the Ticks functionality should be completely redesigned to allow much more flexibility: easy control on the distance from tick marks and the axes/frame, built-in functions for generating Ticks specification with at least that functionality which currently provides the CustomTicks` third-party package (what a shame that for such a basic task we still have to install third-party packages!).
POSTED BY: Alexey Popkov

In response to Alexey's comment on third party packages, which might better be called applications:

There are several problems with third party applications and it would be nice to find solutions. The first problem is the question of stability of the application. If you buy it and write your own notebooks depending on a package, will it work in the future? This depends on the stability of Mathematica over versions, which is only so-so. If, as I discussed in another reply, WRI built capability from the low level up (instead of top down) and the lower level routines were stable, then applications could also be more stable.

The second problem is that there is a general negative attitude toward third party packages, especially if they cost something. Many students are downright insulted if they can't get something for free. (They never seem to look at how much it costs them per hour to go to their schools and how many hours they might save by having a useful application!) It's true that some people will provide free applications just to make contacts, or to show their abilities or they want to provide something useful even if they get no money for it. But is that what everybody should do?

The result of this is that there are not that many significant first-rate application out there.The Mathematica community is diminished by this. I would consider a significant application to be something more like a Springer technical book, but with all the Mathematica advantages such as active routines with documentation and the use of dynamic presentations. If you have to pay for the book, why shouldn't you pay a reasonable price for the application?

Should only WRI write applications? As I mentioned before, this is expecting too much of them. Look at the business model of Apple. Do they write all the apps for the iPhone or iPad? Would those products be nearly as successful if it weren't for all the third party apps that can be purchased for them? In fact, I bet some Mathematica users are hoping to use Mathematica to write successful apps for those products - and make a pretty penny at it. I hope they do.

We need a similar attitude for Mathematica applications.
POSTED BY: David J M Park Jr
Alexey Popkov
Alexey Popkov
Posted 10 years ago

The second problem is that there is a general negative attitude toward third party packages

Indeed there is and the basic reason is not that third-party packages cost money. Even with free packages we experience unexpected difficulties. For example, some time ago I sent to a colleague a Notebook with a couple of publication-quality graphs I prepared using free CustomTicks` package. But he faced strange problems with it: he got cryptic error messages which he was not able to interpret. It took substantial time from both he and me to figure out that all the graphics generated using CustomTicks` package is not completely standalone: it renders nicely inside of Notebook but any modification and even Export require the package to be installed. What a mess! I still do not know a straightforward way to get rid of this dependence. Imagine concerns I feel about installing additional packages: they break the ability to exchange Notebooks with colleagues!
POSTED BY: Alexey Popkov

Over the years, I have purchased several Mathematica add-ons. I no longer do so, primarily for the reasons stated in this thread: you can't share your work that depends on the packages unless the recipient also has the package, and there is no guarantee that the package will not break when a new version came out.

When developing apps for Mac or Windows, one can include the object code for any extra libraries or packages, but this is difficult to do for the non-expert user with Mathematica. The restrictions of the Demonstrations project make it hard to include even unencrypted packages.

I spent most of my coding career as an in-house developer, so I don't have a lot of experience with this. However, I can't see any way to make a commercial product add-on with Mathematica that one could sell at an app store. I can see doing custom work for a client, and the client would have the source code, or at least some understanding that any encrypted files would be maintained. I can see doing work for 'free' and providing the source for others to use and modify. This is the way it was in the early days of personal computing (in the 1970s and early 1980s), and there is a lot of merit in this, even if there is no direct compensation.

So, as much as I would like to support the Mathematica community by buying add-ons, I will no longer do so. I've been burned too many times. I am always looking for useful code, and I hope to start providing 'useful' code now that I have finally detoxed from my former job.

It would be great if Wolfram Research could provide a means for users to provide Mathematica projects that are more involved than Demonstrations.

POSTED BY: George Woodrow III

There are several solution paths for making third party packages available to people who don't have them. If the package is free, say from a WRI archive, why can't they just download and install it? The only problem here is that most packages are written in a messy form and the user has to jump through a few hoops to use them - the main problem being just to load it. They should be able to just unzip it into their $UserBaseDirectory/Applications folder and then use it. I discuss how to set up packages in this manner in the following reply:

http://community.wolfram.com/groups/-/m/t/393033?ppauth=WS2vzf9p

It's just the standard WRI paradigm and works great.

The Presentations application has a CustomTicks (and also free standing scales). You can draw graphics and then transmit them to other people with Mathematica or Export them in various formats. The recipient does not need to have Presentations. (You can't do that with everything in Presentations.) Here is an example.

 << Presentations`

f1[x_] := x^2;
f2[x_] := x^3;
testPlot1 =
 Draw2D[
  {Draw[f1[x], {x, 0, 10}, PlotPoints -> 7],
   Blue, Draw[f2[x]/10, {x, 0, 10}, PlotPoints -> 7]},
  AspectRatio -> 1/GoldenRatio,
  Frame -> True,
  FrameTicks -> {Automatic, Automatic, Automatic,
    CustomTicks[#/10 &, {0, 1000, 200, 4}, 
     CTNumberFunction -> (Style[#, FontColor -> Blue] &)]},
  PlotLabel -> Row[{x^2, " and ", Style[x^3, FontColor -> Blue]}],
  Background -> Legacy@Linen,
  BaseStyle -> {FontSize -> 12},
  ImageSize -> 300]

CustomTicks Plot

Now we use another Presentations feature to hide extensive code within a notebook.

HiddenNotebookData[myCustomPlot, "Test of plot without package", testPlot1]

This generates the following initialization cell:

myCustomPlot=<<Test of plot without package>>;

It is this last statement that you include in the notebook. It contains the hidden plot data between the skeletons, but the above statement does not because I just copied the plain text form of the statement. Then quitting Mathematica and restarting without Presentations:

myCustomPlot

enter image description here

The actual code in the cell is:

myCustomPlot = Graphics[{{{{}, {}, {
Line[CompressedData["
1:eJwVy3k4FAgfwHH3MfFi0CAyYyzJMYRo0v5+WTcvSzuOHimklSuTaZX1bpuo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"]]}}}, 
RGBColor[0, 0, 1], {{{}, {}, {
Line[CompressedData["
1:eJwVknk8FAgfh53NOJvclHNy5b7bafj9SBkllFytyhHZEiY06FA5dmljS4cj
ZhHlWtaRY0oiihyRjDMSratyJbe394/v5/n7eT5fRc+AI95cHBwcqT/3f94z
1vGwWmSZbfO3qksQU6Tq9DyRdc1Jhkcr5gvyJ6rNOsTV9BRzcqFBfeNy0PFJ
s4aT1RNx1FII9EyafWy2BTLLhim8OVUguW9xr+xxGaiN4m58TqgFrnW5Z4M1
6qBddO/rJWo90DrV6KFmxvCgV12SQm+EoIYoV1quOfDzPIMf2U1w9N1u1Tm3
AxCmbe9b1tcCP2i+q49eHoHgAvrrSsJbMOJ4Ivy0xhXyzVlukpkdEPqKn6qg
5AEj3TyzIdR34B4uoOdu5gPSfrbRXd1dkCKVffGTlR/YcyZJG9C7YfltQo9J
Lh1+v/ex8JZAD0jd8DAYqwyBGg0Ni5nsXrhZPZU04BYOi7XB3bbYD5YnO99x
MCNAy6nmTGHfANx46uac8vI6nJoibAqEfIClSKXwQpEYsK19bF1OGIaB6D9N
8mtiYTKuNXG0axh21U0vRLXehGjHuUHRzI/g/aBZQELpFigoSKrtDRiBgYWz
XE2JifB0cs/589RPEHyGe9tRs3vgUu7+NINvFJTXf5nU2ZkM8xHRWzq6R2G0
oBLfWz2A+AN59hwPx6AoTO3V03wm7BJvT9Ghf4ZaPekkndwMaByaHz1h9h+o
lcN9GWYWeORJ6cQLjAPRyq26vzIbksCzfjp7AnTuNXV0uOWBIf/vQjuCJiHQ
oT40YqIA2rvynQ/iFMjI8+YupBfBljPfp3L7poEd6Bqd+LIEMg1ljHsffQHa
tBdD270MTDfNrhJDvsJnf9ZwtsgToBywjCslzEBx7MqbzJoq+KPISeeg/wy8
zzB+dKqKBd1iv3WNdM2A6gvfgoutz4A+dFNOJHMWUvgL5klKL6DG8u/6XOIc
LI0ashYd6kAwr8TXPGAOJiyE6PWJ9fA4mF0SSJ2HS3ycnLZmjbDYO+FMzJqH
HSWNhLzcV2AJa2tMvgU4eELXSX1nEwzxKVq1dy8AzdyS3GbVApoBBtM+pt9B
vDKp7dZsK4R37bu1kfUdzpeMyZTnt4ME80y/Fn0RPvV8YGjkdsApnstXG9iL
cOJiWGcVsxNKfktQPm72Ax4wKbskmO/A1rAs4E+BJfAq7FvvrnwP0U3r3FPZ
y8CV/ot/i1sftD35+pYsvgLhtxPSkqv6QerhUJpb1AoclUzPMlEahIIrL0za
PFch88v2IbbAMCyeLeEhdK4Cw27xIKNzGNA1qwPM10DoitOEF/MjdBlEn/1X
fh1EGjvCY20+gZzihd2T8evQnHGtY0FzFHyFT/OSN9aB3TYsKyI2BmvjNOad
gQ2IyOh2e7X4GUTsYiZYNhwo3lTHHiRNQUXDhp1LFAeGtG/FFPVpcKMyniyw
OPCQ7km1TusvkKPuG6mlwYlcMdpm0hnfgMJzQJbJx4UskuvsiNMcDIXXRe4x
58KuQynsBK55iJqlTLJDubCWumXvyZJ5aPugUUEa50LbuTmBJLnv4FkldPh6
IzceFtST6ty1BATdmAq5DW6cVu3tnV9agoKcDVmWEQ9Oh70fe/BmGRYTv03O
P+TBY5EnoeLKKsT5d0R5R/Iiz6XmvHOym6AzZj3FyeJFt9bbu+8SObDr17rD
6XO8qEeJyJr46SVnXSrH9tiCgUJDL4SiObGEfLeShgS0tKgPm8/iRucUIfkx
BgEZ3jNB+vo8uEaKib5WRMBzavQe6Xoe3L9x4Ui1HBFbvlZsW53mxb4el2mN
dSIeUvZKr/AgIlf8DoWt1fzICAsZT+0SwmxalMzaF3404Q2MaYkURhr3tNiE
ogDyJrL7s422Ynwoi68+VgCt1O/cL7Un4XavY/MXXAWx16Wcu69lGxruTmr8
sCSEp6syLy8TxZE9t1n7RlMYVWwZ6gIMcQwvPM2qdBfG80yGUcpncaxVMim+
/VoY7zZKFVGaJfCQUHfy/qStqGWXN9OSJYUGs7HG7FQSLsQFTQVn7sCotmel
reUknFMJ2vOXuix258/qvmwnoSBLdOZwiSyG+7hq/Mu9DV1kHF93vpbD2n41
hRtnt2H91yMbxGgFtGl8xQd7RLD912DXkW9KmJ61GmPkKILZsQY/qOZk/HZV
h0czQAT3dVy2jkgk4+099zekskTQ3dFCs5ayE3uKfebn+EWR0EBvc7qjjN6p
vIM5faLYMZL+cDFYDfkDY5ZlFkRR0jc1N+KdGhZbEiQShMRwOvObyKq+Oq59
IdoxUAzDT9P/a11Qxzso+MIqRwwHA5J/443SwJdjItnjdHFsTQ1xb+7QxjPV
iS/cboij3Vh8Kj/qIClB7MPbh+LolkaLty/SQbfdEpJVbHEsqK8wCaPp/uwk
HRtrKoF2e5WXnXX1cKeuwrldfJKo/ljS8i9pA2zmyYhNV5JEImPpnoqrAQb2
KuaIUCUxr/dQgHWyAT69Th5a8ZdET/pzGZPthnj0vcrhN12SyPgzbV+9shFG
hmsZ+f0thYZXLfRVnExw5CVlvdBEBkW6JZn2alT8fU+p1wEHGWQLrrEeXqOi
ZolG82d/GXTULtws66fiBeaO+/I5Mqiv30kSum2K/OEburfEtuMpi/xvxQRA
fZ26U8Gz23H2/YBytYA5Xku2bqHky+KM/84A1dOWqEKq02c3yuIlj0IJh78t
sTmGkhw0IosGLYKqE72WKBas4VMgLYfX+dcFnWz34WNbIQ65P+RQWMu70pS6
H99ydxhwesvjVdlTn1I0aUgyKWj1SlBAWes0Cnja4PK7u6YqaQq4wjxMo+Ta
4EhgROF4ngIO2363zp+xwdK8IzfPNSrgoP6bopmrh9BJbtmGsa6AqjELZaKP
bPEB7/6WuLOK+OVCwVZitD2qdg01/2ulhP8UZyq9knBAEr2JEuyohFpjpBtc
Fg64JFSaZ+ylhEvPQokR5xyw2SomjnVFCSNT7/JSGxzQj6V5oKH850+fZ7u/
YRzFksywph4yGZdCtJzPTDhiKnj9kqpHRq8jlxdapZwwasAm9ziQEdutykJo
TugooRA7coyMjhMFJ24/dsKl2Eba9C0ymrm4PuH1c8aPKsWV/zDJyJiVf56Q
5ozN9clq9EIyGuUq0k+2O2Pquh9x8TUZLUqN77w1cMGoFKfQym4yyiiv+Jz3
cUE/ExwPHyXjxQWXnGPJLujYpe5iOkdGbT2NyNgWFzSji77e3CTj/CRNe3PT
Bf8HSKJtAA==
"]]}}}}, AspectRatio -> GoldenRatio^(-1), Frame -> True, 
   FrameTicks -> {Automatic, Automatic, Automatic, {{0, 
Style[0, FontColor -> RGBColor[0, 0, 1]], {0.0125, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.25]}}, {20, 
Style[200, FontColor -> RGBColor[0, 0, 1]], {0.0125, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.25]}}, {40, 
Style[400, FontColor -> RGBColor[0, 0, 1]], {0.0125, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.25]}}, {60, 
Style[600, FontColor -> RGBColor[0, 0, 1]], {0.0125, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.25]}}, {80, 
Style[800, FontColor -> RGBColor[0, 0, 1]], {0.0125, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.25]}}, {100, 
Style[1000, FontColor -> RGBColor[0, 0, 1]], {0.0125, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.25]}}, {5, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {10, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {15, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {25, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {30, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {35, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {45, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {50, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {55, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {65, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {70, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {75, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {85, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {90, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}, {95, "", {0.0075, 0}, {
GrayLevel[0.], 
AbsoluteThickness[0.125]}}}}, PlotLabel -> Row[{x^2, " and ", 
Style[x^3, FontColor -> RGBColor[0, 0, 1]]}], 
   Background -> RGBColor[0.980407, 0.941206, 0.902005], 
   BaseStyle -> {FontSize -> 12}, ImageSize -> 300, 
   PlotRange -> Automatic, PlotRangeClipping -> True];

It is also possible to provide free versions of packages that can be used to evaluate notebooks but are not very useful for writing notebooks. I provide such free versions of Presentations and ExtendUnits at my web site. They are condensed and do not contain any documentation or useful usage messages.

There is also an Applications folder in the free CDF player where readers could place such packages.

Again, I envision that the best form of applications would be like advanced textbooks but with much greater power and flexibility. They might make a great platform for joint research. Or for courseware. If they were priced in line with current textbooks or advanced technical books it would not be out of line for people who wanted to participate to buy and install them.
POSTED BY: David J M Park Jr

Thanks for the information. I was not aware of some of these options.

Once a Mathematica 10 compliant CDF player has been released, I will check them out, using my wife as a beta tester.
POSTED BY: George Woodrow III
Alexey Popkov
Alexey Popkov
Posted 10 years ago

Again, I envision that the best form of applications would be like advanced textbooks but with much greater power and flexibility.

That sounds reasonable but I have not got the idea. Could you be more specific about how such an application may be organized and worked with?
POSTED BY: Alexey Popkov

In the context of this question and this reply the following lines from 'Practical Foundations of Mathematics' by Paul Taylor (Cambridge Studies in Advanced Mathematics, 1999, p. 470) may be of interest: "On the other hand, the tite of technology will drive mathematicians into publishing their arguments in computer-encoded form. Theorems which provide nirvana will lose out to those that are programs and do calculations for their users on demand. A new philosophical and semantic basis is needed to save mathematics from being reduced again to programming." Shortly after reading this I started to contribute to the Wolfram Demonstrations project and felt to be not too far away from what Taylor is speaking about.
POSTED BY: Ulrich Mutze

It's a matter of how to organize your Mathematica work and how to get the optimum use of Mathematica. My guess is that the most common usage is just as a super graphical calculator where a result is obtained or a graphic produced and these are copied out to some other document. This is fine enough, but it's not so good at building a stable usable knowledge base. Six months from now will you be able to find the notebook that made that plot, or the routine for some calculation and remember how to use it? WRI has provided really great facilities for doing better. (But they could polish them up some and make them easier to use!)

It's called an "application" and the place to put them is in your $UserBaseDirectory/Applications' folder. On another reply on this page I have a link to a detailed discussion on how to set up an application. Some might think this is only a place for WRI to put applications - but no, these are your folders and you can put anything there you want.

An application may contain a folder structure and may or may not contain packages and documentation. It will be organized around some particular topic or purpose. Some typical applications might be:

  1. Some topic of individual study
  2. A course a student is taking
  3. Courseware for a course a professor is teaching
  4. A research project and possibly papers spun off from the project
  5. A book

Almost any serious project would generate routines adapted to it. Some of them might just be convenience routines that adapt or assemble Mathematica routines to the specific topic. Most applications probably would eventually contain packages. It is easy to write package files and, if you set them up correctly, easy to load and use them from anywhere. I usually develop a routine while working on some topic in a notebook. I put it in a Routines Section (Package purgatory) and include a usage message, SyntaxInformation, and other definitions that might go with it. Then once a routine gets some testing and usage you might move it to Package heaven.

Eventually you might add WRI style documentation - but you don't need it at first. Here it would be nice if WRI had a freely available application just devoted to writing their standard documentation. It wouldn't need the full features of Workbench. It could be simplified and once you learn the ropes it's quite easy to add documentation pages. They can be quite useful.

You can also quite easily add palettes and style sheets and an init.m file, even if you don't add formal documentation.

Most importantly, an application would contain various collections of notebooks. Maybe polished literate notebooks that could be turned into sections or chapters of a book. Maybe a folder of homework assignments. Maybe just your personal tutorials on various subtopics. Maybe a group of development and testing notebooks.

The important thing here is that you're building up a knowledge and skills base. It can have long term usefulness to yourself and maybe become something seriously useful to other people. When that point comes you can just zip it up (perhaps removing some private folders) and send it to another person. They just do one unzip into their own $UserBaseDirectory/Applications folder and they're in business. The other person could even add his own package or style sheet or palette for special work he might do as a spin off. This is a very flexible structure and one that can be ideal for collaboration.

If you are writing a book you can adapt it to a Mathematica application. The printed version of the book might be shorter and more elegant. It would not have to be filled with very many examples and might not contain any Mathematica code. Long examples can be especially poor if they include large structures that may fill an entire page. An accompanying application could contain much longer literate tutorial notebooks with the active capability of doing calculations. Long examples are much better handled.

By writing literate notebooks, a student could build up his own body of work on a subject. A set of such notebooks would be a much better display of her capability than grades in a course. Everyone should build up and preserve their work in this way. Otherwise why do it? Your work is worth preserving.

That's the basic idea of getting more from Mathematica. We also have to remember that Mathematica is a relatively new medium for doing and communicating technical work. We have only scratched the surface on how to employ this medium. Just copying or making simple adaptations of 19th and 20th century paradigms is far too limiting. It's a new field where many people can and will make new innovations. Great masterworks are yet to be written.
POSTED BY: David J M Park Jr
Alexey Popkov
Alexey Popkov
Posted 10 years ago

It would be great if Wolfram Research could provide a means for users to provide Mathematica projects that are more involved than Demonstrations.

I agree absolutely. We all need some basic functional we can rely upon. Currently we have some extremely limited reliable basic functional which seemingly was not extended since the Mathematica version 3.
POSTED BY: Alexey Popkov

David, I read your wish and while I was redoing my keyboard shortcut code I added a "Command Option M" keyboard shortcut ("Cmd Alt M" on Windows, "Mod1 Mod2 M" on Linux) here. It is a bit slow (on MacOSX, faster on Windows), but it works. I am sure the good folks at Wolfram will implement something like this for some future release. It is not that hard to do.
POSTED BY: Rolf Mertig
David G
David G
Posted 10 years ago

I'm on a Win 8.1 PC. I've submitted two problem reports to WRI (both confirmed). One would result in a front end lock up. The other would result in a PC lock up. I haven't experience your problems with crashes, but I have experienced timeouts when using WolframAlpha. I've read about other issues like the spell check problem. I think this release was not up to the usual WRI standards. I know WRI is working to correct the issues.
POSTED BY: David G
Collin Merenoff
Collin Merenoff
Posted 10 years ago

I've had this problem too. If it's caused by Undo (I've thought of this also), it would help if there were a command to clear the Undo cache, that could be used occasionally during a process (such as, in my case, a long sequence of non-local image transformations) you're afraid might cause a crash.

(Note that occasionally saving the notebook doesn't help much, because it's often during a save that the crash occurs.)
POSTED BY: Collin Merenoff
Bill Simpson
Bill Simpson
Posted 10 years ago

I don't think the details of his platform would be nearly as helpful to anyone attempting to reproduce this or possibly even diagnose this as a notebook containing n independent specific examples with directions to 1: reboot the machine, 2: boot Mathematica, 3: open this notebook, 4: evaluate a single specific cell in this notebook and 5: based on his repeated testing and for for his platform evaluating this cell will crash Mathematica about x% of the time. Since he has, more or less, reproducible crashes then this should be straightforward to do, it is the ones that can't be reproduced or even narrowed down to a specific example that are the harder ones. Otherwise this sounds like "I typed some stuff in, some stuff came out, some stuff is wrong, what?" that have been posted by some users in the past.
POSTED BY: Bill Simpson

John,

The spell check crash in Mathematica 10.0.1 has been reported to support@wolfram.com (and it has been fixed in the upcoming Mathematica 10.0.2 release).
POSTED BY: Arnoud Buzing

John,

I am running M10 under the latest Mac OS X and have no such stability issues. As others have suggested, more details on your platform would help.

David Mackay
POSTED BY: David Mackay

I am using windows 8 and it is fine. Looks like something is really wrong with higher version of windows. Ulrich Mutze, I think you should contact Wolfram help center.
POSTED BY: suvadip mandal

I'm using Windows 8.1 and my experience is not too different from John McGee's.
POSTED BY: Ulrich Mutze

Actually the note was meant for John McGee ;-) . And, yes, the crash reports are kind of like looking at the insides of sausage and trying to figure out what animals contributed....

POSTED BY: David Reiss

Of course -- including the crash report generated by OS X. I've only had 2 or 3, and they aren't strictly deterministic. I don't think that they are random either. I'm not good at reading the goat entrails from the crash logs. ;-)
POSTED BY: George Woodrow III

It has been stable for me as well (OSX).

But, if you are able to create any reproducible crashes I hope that you reported them as bugs to WRI.
POSTED BY: David Reiss

Perhaps you could tell what OS you are using. I am using OS X (10.10), and see none of your symptoms. I have had a couple hard crashes (sent info to Wolfram Support), but re-opening the notebook was successful.

From a recent virtual event, someone at Wolfram indicated that there will be a 10.0.2 update "soon". Perhaps this update will resolve your problems.
POSTED BY: George Woodrow III

I am using Windows 7 Enterprise, Service Pack 1. I am looking forward to 10.0.2. I have heard that it will be released soon as well.
POSTED BY: John McGee

Hi, I am a Mathematica user too and I use Mathematica 10 but I do not see any discrepancies regarding crashing of the software. It is doing well. Perhaps your installation was not done properly or some files were missing.

POSTED BY: suvadip mandal
Reply to this discussion
Community posts can be styled and formatted using the Markdown syntax.
Tag limit exceeded
Note: Only the first five people you tag will receive an email notification; the other tagged names will appear as links to their profiles.
Reply Preview
Attachments
Remove
or Discard

Group Abstract Group Abstract