Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.soft-sys.math.mathematica > #10869 > unrolled thread
| Started by | John Fultz <jfultz@wolfram.com> |
|---|---|
| First post | 2012-07-11 06:18 +0000 |
| Last post | 2012-07-26 07:32 +0000 |
| Articles | 18 — 10 participants |
Back to article view | Back to comp.soft-sys.math.mathematica
Re: Sending an interrupt to the frontend? John Fultz <jfultz@wolfram.com> - 2012-07-11 06:18 +0000
Re: Sending an interrupt to the frontend? Yves Klett <yves.klett@googlemail.com> - 2012-07-12 09:00 +0000
Re: Sending an interrupt to the frontend? David Bailey <dave@removedbailey.co.uk> - 2012-07-14 05:30 +0000
Re: Sending an interrupt to the frontend? "Alexey Popkov" <lehin.p@gmail.com> - 2012-07-15 08:29 +0000
Re: Sending an interrupt to the frontend? Ralph Dratman <ralph.dratman@gmail.com> - 2012-07-15 08:28 +0000
Re: Sending an interrupt to the frontend? David Bailey <dave@removedbailey.co.uk> - 2012-07-18 05:38 +0000
Re: Sending an interrupt to the frontend? leigh pascoe <leigh@evry.inserm.fr> - 2012-07-19 07:52 +0000
Re: Sending an interrupt to the frontend? Michael Weyrauch <michael.weyrauch@gmx.de> - 2012-07-19 07:51 +0000
Re: Sending an interrupt to the frontend? David Bailey <dave@removedbailey.co.uk> - 2012-07-22 08:32 +0000
Re: Sending an interrupt to the frontend? W Craig Carter <ccarter@MIT.EDU> - 2012-07-20 07:50 +0000
Re: Sending an interrupt to the frontend? James Stein <mathgroup@stein.org> - 2012-07-20 07:52 +0000
Re: Sending an interrupt to the frontend? James Stein <mathgroup@stein.org> - 2012-07-23 05:03 +0000
Re: Sending an interrupt to the frontend? George Woodrow III <georgevw3@mac.com> - 2012-07-23 23:56 +0000
Re: Sending an interrupt to the frontend? Ralph Dratman <ralph.dratman@gmail.com> - 2012-07-23 05:05 +0000
Re: Sending an interrupt to the frontend? Michael Weyrauch <michael.weyrauch@gmx.de> - 2012-07-23 23:55 +0000
Re: Sending an interrupt to the frontend? Ralph Dratman <ralph.dratman@gmail.com> - 2012-07-23 23:55 +0000
Re: Sending an interrupt to the frontend? Ralph Dratman <ralph.dratman@gmail.com> - 2012-07-25 06:32 +0000
Re: Sending an interrupt to the frontend? Yves Klett <yves.klett@googlemail.com> - 2012-07-26 07:32 +0000
| From | John Fultz <jfultz@wolfram.com> |
|---|---|
| Date | 2012-07-11 06:18 +0000 |
| Subject | Re: Sending an interrupt to the frontend? |
| Message-ID | <jtj5ro$5ml$1@smc.vnet.net> |
It would be nice if the front end were more responsive in these cases (says the guy who would be responsible for making it happen). In the mean time, one thing which usually works pretty well is to kill the MathKernel process. Doing so will typically leave your front end intact and make it responsive again. You can do this pretty easily from the Activity Monitor in MacOS, or the Task Manager (looking at the Processes tab...*not* the Applications tab) in Windows. Sincerely, John Fultz jfultz@wolfram.com User Interface Group Wolfram Research, Inc. On Tue, 10 Jul 2012 00:40:50 -0400 (EDT), W Craig Carter wrote: > > Hello Mathgroup, > > This is a question about frozen frontend behavior. > > In development stages, one of my frequent mistakes is to send the > frontend something that takes forever to dynamically update---at least > that is what I believe what is happening for most of the "freezing" > occurrences. For MacOs, this is often signaled by a "Formatting > Notebook Contents" window. > > I wonder if anyone has found a method to send the front end a message to > stop dynamically updating while in an unresponsive state? I've various > versions of kill -s signal (i.e., signal = INT) from a terminal in > MacOSx, but never with success. > > I suppose that having the front end query the operating system for > interrupt requests would create a lot of overhead. However, I wonder if > a method to force the frontend to make an operating system query with a > user-specified time interval might be possible? > > W Craig Carter
[toc] | [next] | [standalone]
| From | Yves Klett <yves.klett@googlemail.com> |
|---|---|
| Date | 2012-07-12 09:00 +0000 |
| Message-ID | <jtm3ng$ge9$1@smc.vnet.net> |
| In reply to | #10869 |
In earlier incarnations, the kernel would show up as a separate entry in the taskbar (on Win XP, that was), which made it very convenient to kill. I kind of miss that behaviour (when things go wrong repeatedly). Regards, Yves Am 11.07.2012 08:18, schrieb John Fultz: > It would be nice if the front end were more responsive in these cases (says the > guy who would be responsible for making it happen). In the mean time, one thing > which usually works pretty well is to kill the MathKernel process. Doing so > will typically leave your front end intact and make it responsive again. > > You can do this pretty easily from the Activity Monitor in MacOS, or the Task > Manager (looking at the Processes tab...*not* the Applications tab) in Windows. > > Sincerely, > > John Fultz > jfultz@wolfram.com > User Interface Group > Wolfram Research, Inc. > > > On Tue, 10 Jul 2012 00:40:50 -0400 (EDT), W Craig Carter wrote: >> >> Hello Mathgroup, >> >> This is a question about frozen frontend behavior. >> >> In development stages, one of my frequent mistakes is to send the >> frontend something that takes forever to dynamically update---at least >> that is what I believe what is happening for most of the "freezing" >> occurrences. For MacOs, this is often signaled by a "Formatting >> Notebook Contents" window. >> >> I wonder if anyone has found a method to send the front end a message to >> stop dynamically updating while in an unresponsive state? I've various >> versions of kill -s signal (i.e., signal = INT) from a terminal in >> MacOSx, but never with success. >> >> I suppose that having the front end query the operating system for >> interrupt requests would create a lot of overhead. However, I wonder if >> a method to force the frontend to make an operating system query with a >> user-specified time interval might be possible? >> >> W Craig Carter > > >
[toc] | [prev] | [next] | [standalone]
| From | David Bailey <dave@removedbailey.co.uk> |
|---|---|
| Date | 2012-07-14 05:30 +0000 |
| Message-ID | <jtr050$bc5$1@smc.vnet.net> |
| In reply to | #10897 |
On 12/07/2012 10:00, Yves Klett wrote: > In earlier incarnations, the kernel would show up as a separate entry in > the taskbar (on Win XP, that was), which made it very convenient to > kill. I kind of miss that behaviour (when things go wrong repeatedly). I wrote a C program that executes the command c:\windows\System32\taskkill.exe /im MathKernel.exe /t /f This runs in the background all the time, and responds to a hot key! The fact that I took time to set this up, probably reflects just how troublesome kernel hangs can be! Perhaps at the very least Mathematica could spawn a program of this type. David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | "Alexey Popkov" <lehin.p@gmail.com> |
|---|---|
| Date | 2012-07-15 08:29 +0000 |
| Message-ID | <jttv15$gu9$1@smc.vnet.net> |
| In reply to | #10897 |
The default MathKernel process with name "Local" is launched (starting from the version 6) with the '-noicon' command-line option which hides it from the taskbar under Windows. It is possible to create auto-launching kernel without this option (say "Local+") by using the "Kernel Configuration dialog" and removing the '-noicon' part in the "Arguments to MLOpen" field under "Advanced options" (one should also set "Automatically launch on fromt end startup"). After this we can set "Local+" as the default kernel globally in the "Evaluation :: Default kernel" menu and the kernel will show up as a separate entry in the taskbar by default. HTH, Alexey "Yves Klett" <yves.klett@googlemail.com> wrote: news:jtm3ng$ge9$1@smc.vnet.net... > In earlier incarnations, the kernel would show up as a separate entry in > the taskbar (on Win XP, that was), which made it very convenient to > kill. I kind of miss that behaviour (when things go wrong repeatedly). > > Regards, > Yves
[toc] | [prev] | [next] | [standalone]
| From | Ralph Dratman <ralph.dratman@gmail.com> |
|---|---|
| Date | 2012-07-15 08:28 +0000 |
| Message-ID | <jttuv8$gtl$1@smc.vnet.net> |
| In reply to | #10869 |
David, "Troublesome" puts the matter rather tactfully. Bluntly, there is no excuse for a major product to display such a level of instability in 2012. Since I personally like Mathematica so much, and because I use it constantly, I find the crashes to be both an embarrassment and a disappointment. I can only hope Wolfram Research will soon get its act together on this critically important issue. Ralph On Sat, Jul 14, 2012 at 1:28 AM, David Bailey <dave@removedbailey.co.uk> wrote: > On 12/07/2012 10:00, Yves Klett wrote: >> In earlier incarnations, the kernel would show up as a separate entry in >> the taskbar (on Win XP, that was), which made it very convenient to >> kill. I kind of miss that behaviour (when things go wrong repeatedly). > > I wrote a C program that executes the command > > c:\windows\System32\taskkill.exe /im MathKernel.exe /t /f > > This runs in the background all the time, and responds to a hot key! > > The fact that I took time to set this up, probably reflects just how > troublesome kernel hangs can be! > > Perhaps at the very least Mathematica could spawn a program of this type. > > David Bailey > http://www.dbaileyconsultancy.co.uk > >
[toc] | [prev] | [next] | [standalone]
| From | David Bailey <dave@removedbailey.co.uk> |
|---|---|
| Date | 2012-07-18 05:38 +0000 |
| Message-ID | <ju5i5g$3rd$1@smc.vnet.net> |
| In reply to | #10931 |
On 15/07/2012 09:28, Ralph Dratman wrote: > David, > > "Troublesome" puts the matter rather tactfully. > > Bluntly, there is no excuse for a major product to display such a > level of instability in 2012. > > Since I personally like Mathematica so much, and because I use it > constantly, I find the crashes to be both an embarrassment and a > disappointment. > > I can only hope Wolfram Research will soon get its act together on > this critically important issue. > > Ralph > I broadly agree with that - and without my solution, I would find these hangs VERY frustrating! I think I can understand if hangs happen while user code is executing, but on occasions, this can happen for no obvious reasons - Mathematica is just starting up! I think it would be great if we could get a discussion of this at the forthcoming technology conference. David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | leigh pascoe <leigh@evry.inserm.fr> |
|---|---|
| Date | 2012-07-19 07:52 +0000 |
| Message-ID | <ju8ec6$9a2$1@smc.vnet.net> |
| In reply to | #10931 |
Le 18/07/2012 07:37, David Bailey a =C3=A9crit : > On 15/07/2012 09:28, Ralph Dratman wrote: >> David, >> >> "Troublesome" puts the matter rather tactfully. >> >> Bluntly, there is no excuse for a major product to display such a >> level of instability in 2012. >> >> Since I personally like Mathematica so much, and because I use it >> constantly, I find the crashes to be both an embarrassment and a >> disappointment. >> >> I can only hope Wolfram Research will soon get its act together on >> this critically important issue. >> >> Ralph >> > I broadly agree with that - and without my solution, I would find these > hangs VERY frustrating! > > I think I can understand if hangs happen while user code is executing, > but on occasions, this can happen for no obvious reasons - Mathematica > is just starting up! > > I think it would be great if we could get a discussion of this at the > forthcoming technology conference. > > David Bailey > http://www.dbaileyconsultancy.co.uk > > > I would also agree with that. Mathematica seems to hang for no apparent reason and the only solution is to kill the process and restart, often losing work in progress. I posted a query about this several times on the forum, but got no replies apart from someone who confirmed that they experienced the same problem. It is difficult to contact Wolfram technical help without a specific sequence that crashes the program. Leigh
[toc] | [prev] | [next] | [standalone]
| From | Michael Weyrauch <michael.weyrauch@gmx.de> |
|---|---|
| Date | 2012-07-19 07:51 +0000 |
| Message-ID | <ju8ea9$99d$1@smc.vnet.net> |
| In reply to | #10931 |
Ralph,
I really would like to understand your critical remarks somewhat
better.
It is clear that one can easily and quickly run the frontend irresponsive.
However, in most cases I know, this is actually due to bad programming
(from Mathematica's point of view) rather than an instable product.
One typical reason is that a command returns symbolic results where the
programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended?
It is the tremendous flexibility and the many possibilities which
sometims get into the way, and as a consequence the frontend can not
handle the output from the kernel any more.
I really do not understand where you expect Wolfram to get "its act
together". My experience tells me: A good Mathematica program may run
for days without any instability. But my stupitidy and/or lasy
programming can run it against
the wall within seconds. Mathematica as such is definitely not unstable.
(of course, sometimes there are bugs as with any other major (and minor)
software).
Michael
Am 15.07.2012 10:28, schrieb Ralph Dratman:
> David,
>
> "Troublesome" puts the matter rather tactfully.
>
> Bluntly, there is no excuse for a major product to display such a
> level of instability in 2012.
>
> Since I personally like Mathematica so much, and because I use it
> constantly, I find the crashes to be both an embarrassment and a
> disappointment.
>
> I can only hope Wolfram Research will soon get its act together on
> this critically important issue.
>
> Ralph
>
>
> On Sat, Jul 14, 2012 at 1:28 AM, David Bailey <dave@removedbailey.co.uk> wrote:
>> On 12/07/2012 10:00, Yves Klett wrote:
>>> In earlier incarnations, the kernel would show up as a separate entry in
>>> the taskbar (on Win XP, that was), which made it very convenient to
>>> kill. I kind of miss that behaviour (when things go wrong repeatedly).
>>
>> I wrote a C program that executes the command
>>
>> c:\windows\System32\taskkill.exe /im MathKernel.exe /t /f
>>
>> This runs in the background all the time, and responds to a hot key!
>>
>> The fact that I took time to set this up, probably reflects just how
>> troublesome kernel hangs can be!
>>
>> Perhaps at the very least Mathematica could spawn a program of this type.
>>
>> David Bailey
>> http://www.dbaileyconsultancy.co.uk
>>
>>
>
[toc] | [prev] | [next] | [standalone]
| From | David Bailey <dave@removedbailey.co.uk> |
|---|---|
| Date | 2012-07-22 08:32 +0000 |
| Message-ID | <jugdqj$ep2$1@smc.vnet.net> |
| In reply to | #10985 |
On 19/07/2012 08:51, Michael Weyrauch wrote: > Ralph, > > I really would like to understand your critical remarks somewhat > better. > > It is clear that one can easily and quickly run the frontend irresponsive. > However, in most cases I know, this is actually due to bad programming > (from Mathematica's point of view) rather than an instable product. > > One typical reason is that a command returns symbolic results where the > programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended? > > It is the tremendous flexibility and the many possibilities which > sometims get into the way, and as a consequence the frontend can not > handle the output from the kernel any more. > > I really do not understand where you expect Wolfram to get "its act > together". My experience tells me: A good Mathematica program may run > for days without any instability. But my stupitidy and/or lasy > programming can run it against > the wall within seconds. Mathematica as such is definitely not unstable. > (of course, sometimes there are bugs as with any other major (and minor) > software). > > Michael > I am not sure it is always as simple as just blaming the user! I have seen Mathematica hang when all I have done is start it up and look something up in the help system (or try to). My feeling is that Mathematica could learn something from the Windows GUI. When most events happen in Windows (e.g. someone pushes a button), the information doesn't get posted into the program pre-emptively, as I think happens with Mathematica - it gets added to a list of messages, which is read in a message loop. This means that everything happens in a predictable way, without race hazards. I strongly suspect that this is why Mathematica has a slightly glitchy feel. I really don't understand why WRI feel this problem is insoluble (assuming they do - it has been like that since version 6.0). That leaves complicated situations involving Dynamic. This may indeed create tricky problems, but if so, why didn't WRI use a more robust scheme? David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | W Craig Carter <ccarter@MIT.EDU> |
|---|---|
| Date | 2012-07-20 07:50 +0000 |
| Message-ID | <jub2kg$efo$1@smc.vnet.net> |
| In reply to | #10931 |
Yikes. As the original poster, I'd like to clarify that I was looking for a way to send an interrupt to the front-end *from the operating system*. I think mathematica's behavior is understandable when the front end receives a request to dynamically update a result that is so large that takes a long time to format. This is nearly always triggered by a mistake that I have made. I was looking for a work-around; not a fix to Mathematica. Ralph Draftman send a nice way to catch interrupts with an Internal`AddHandler. W Craig Carter Professor of Materials Science, MIT > > It is clear that one can easily and quickly run the frontend irresponsive. > However, in most cases I know, this is actually due to bad programming > (from Mathematica's point of view) rather than an instable product. > > One typical reason is that a command returns symbolic results where the > programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended? > >>> >> >
[toc] | [prev] | [next] | [standalone]
| From | James Stein <mathgroup@stein.org> |
|---|---|
| Date | 2012-07-20 07:52 +0000 |
| Message-ID | <jub2nb$egk$1@smc.vnet.net> |
| In reply to | #10931 |
Dear Michael, You asked of Ralph; but I wish to answer as well (although my opinions of Mathematica are much higher than Ralph's). Most users sometimes make mistakes. (I make many.) Sometimes an evaluation which ought to complete in a short time takes a long time and may be on its way to infinity. Finite beings will wish to abort such evaluations. Were Mathematica a single process, occasional difficulty in interrupting a calculation would be understandable, perhaps forgivable, perhaps unpreventable. Whatever tight (efficient) loops may exist in the program could be substantially slowed if they had to "listen for interrupts"; possible solutions are difficult because different hardwares and different operating systems differ substantially. But as I understand it, Mathematica is commonly implemented as two processes, a FrontEnd (the interactive Notebook) and a BackEnd (the kernel). Assume the kernel is running away, computing an Ackermann function perhaps. I imagine two cases: (1) the kernel is busy computing and sending no output. (2) the kernel is flooding the FrontEnd with more output than it can format and handle in real time. Case 1 seems unproblematic to me. The FrontEnd is idle, it should be easy to respond to human input and interrupt the kernel if possible, otherwise abort it. In either case, the FrontEnd should survive and Notebooks can be saved. Case 2 is the problem. Both the FrontEnd and the BackEnd are busy busy busy. If the FrontEnd is merely receiving a gazillion short lines to output, it seems it could handle interrupts after every line. So likely the problem is when the FrontEnd receives an output so large in size that it goes into a very long loop formatting that output. I would hope that somewhere in that loop would be a place to look for interrupts. This would slow formatting (not by much, I would hope), but in normal cases this would not matter much (10.1 seconds instead of 10 seconds) and in the problematic case, does user care if formatting takes 12 years and a month instead of 12 years? So that's my naive view, and why I think the problem ought be solvable, unless in the face of memory issues. In olden times, when the stack crashed into the heap, all bets were off. I'm not aware of how more modern memory management works, but would hope that the FrontEnd, while checking for an interrupt could also check for how much free memory remains and, if it looks dubious, could do something intelligent (alert user and wait?) before disaster strikes. Of course, I am a computer dinosaur so these views may look very silly to current experts. Best regards to all, -- James On Thu, Jul 19, 2012 at 12:50 AM, Michael Weyrauch <michael.weyrauch@gmx.de> wrote: > Ralph, > > I really would like to understand your critical remarks somewhat > better. > > It is clear that one can easily and quickly run the frontend irresponsive. > However, in most cases I know, this is actually due to bad programming > (from Mathematica's point of view) rather than an instable product. > > One typical reason is that a command returns symbolic results where the > programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended? > > It is the tremendous flexibility and the many possibilities which > sometims get into the way, and as a consequence the frontend can not > handle the output from the kernel any more. > > I really do not understand where you expect Wolfram to get "its act > together". My experience tells me: A good Mathematica program may run > for days without any instability. But my stupitidy and/or lasy > programming can run it against > the wall within seconds. Mathematica as such is definitely not unstable. > (of course, sometimes there are bugs as with any other major (and minor) > software). > > Michael > > > Am 15.07.2012 10:28, schrieb Ralph Dratman: >> David, >> >> "Troublesome" puts the matter rather tactfully. >> >> Bluntly, there is no excuse for a major product to display such a >> level of instability in 2012. >> >> Since I personally like Mathematica so much, and because I use it >> constantly, I find the crashes to be both an embarrassment and a >> disappointment. >> >> I can only hope Wolfram Research will soon get its act together on >> this critically important issue. >> >> Ralph >> >> >> On Sat, Jul 14, 2012 at 1:28 AM, David Bailey <dave@removedbailey.co.uk> wrote: >>> On 12/07/2012 10:00, Yves Klett wrote: >>>> In earlier incarnations, the kernel would show up as a separate entry in >>>> the taskbar (on Win XP, that was), which made it very convenient to >>>> kill. I kind of miss that behaviour (when things go wrong repeatedly). >>> >>> I wrote a C program that executes the command >>> >>> c:\windows\System32\taskkill.exe /im MathKernel.exe /t /f >>> >>> This runs in the background all the time, and responds to a hot key! >>> >>> The fact that I took time to set this up, probably reflects just how >>> troublesome kernel hangs can be! >>> >>> Perhaps at the very least Mathematica could spawn a program of this type. >>> >>> David Bailey >>> http://www.dbaileyconsultancy.co.uk >>> >>> >> > >
[toc] | [prev] | [next] | [standalone]
| From | James Stein <mathgroup@stein.org> |
|---|---|
| Date | 2012-07-23 05:03 +0000 |
| Message-ID | <juilum$k8j$1@smc.vnet.net> |
| In reply to | #10931 |
On Sun, Jul 22, 2012 at 1:31 AM, David Bailey <dave@removedbailey.co.uk>wrote: > > I am not sure it is always as simple as just blaming the user! I have > seen Mathematica hang when all I have done is start it up and look > something up in the help system (or try to). > I also have seen the bad behavior Dave reports, in two guises: (a) launch mathematica, and it hangs (before, I think, showing the splash screen). (b) launch Mathematica, access help system, and it hangs while "formatting". (On a Macintosh, fwiw)
[toc] | [prev] | [next] | [standalone]
| From | George Woodrow III <georgevw3@mac.com> |
|---|---|
| Date | 2012-07-23 23:56 +0000 |
| Message-ID | <jukoau$o07$1@smc.vnet.net> |
| In reply to | #10931 |
I only rarely see this behaviour. (I also use Macs.) When something like this happens, starting the app with the option key down (I think) resets Mathematica. The problems go away. Of course, there are any number of other problems that are not helped, but this trick works for me in many cases. I might have to do this once every 6 months or a year. I had to do this most recently -- for almost exactly the symptoms you describe. The problem has not happened again. Hope this helps. george On Jul 23, 2012, at 1:02 AM, James Stein wrote: > On Sun, Jul 22, 2012 at 1:31 AM, David Bailey <dave@removedbailey.co.uk>wrote: > >> >> I am not sure it is always as simple as just blaming the user! I have >> seen Mathematica hang when all I have done is start it up and look >> something up in the help system (or try to). >> > > I also have seen the bad behavior Dave reports, in two guises: > (a) launch mathematica, and it hangs (before, I think, showing the splash screen). > (b) launch Mathematica, access help system, and it hangs while "formatting". > (On a Macintosh, fwiw)
[toc] | [prev] | [next] | [standalone]
| From | Ralph Dratman <ralph.dratman@gmail.com> |
|---|---|
| Date | 2012-07-23 05:05 +0000 |
| Message-ID | <juim3g$k9m$1@smc.vnet.net> |
| In reply to | #10869 |
Michael, I understand your point about "bad programming," but must respectfully disagree. I am only asking that the front end remain responsive to a user interrupt, no matter what else happens. It already has a very nice menu item to stop evaluation. Why should such a command ever fail, or be shown as disabled? This is not magic, but ordinary system-level programming. It may amount to just a few hundred lines of code, causing no loss of performance whatsoever. There are probably a dozen technical people at Wolfram who are perfectly capable of fixing the problem. Anyway, perhaps I am not being quite as harsh or negative as you think. A bit of direct talk is necessary in this case. I would not be writing anything at all if I did not like Mathematica as much as I do. Ralph On 19/07/2012 08:51, Michael Weyrauch wrote: >> Ralph, >> >> I really would like to understand your critical remarks somewhat >> better. >> >> It is clear that one can easily and quickly run the frontend irresponsive. >> However, in most cases I know, this is actually due to bad programming >> (from Mathematica's point of view) rather than an instable product. >> >> One typical reason is that a command returns symbolic results where the >> programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended? >> >> It is the tremendous flexibility and the many possibilities which >> sometims get into the way, and as a consequence the frontend can not >> handle the output from the kernel any more. >> >> I really do not understand where you expect Wolfram to get "its act >> together". My experience tells me: A good Mathematica program may run >> for days without any instability. But my stupitidy and/or lasy >> programming can run it against >> the wall within seconds. Mathematica as such is definitely not unstable. >> (of course, sometimes there are bugs as with any other major (and minor) >> software). >> >> Michael
[toc] | [prev] | [next] | [standalone]
| From | Michael Weyrauch <michael.weyrauch@gmx.de> |
|---|---|
| Date | 2012-07-23 23:55 +0000 |
| Message-ID | <jukoa0$nvr$1@smc.vnet.net> |
| In reply to | #11041 |
Ralph, if you just ask for responsiveness to a user interrupt, then I am fully with you. It bites me often that a calculation goes astray because I did not anticipate correctly what is going to happen. And no doubt, these are standard user errors which can not be avoided, and always happen... to everyone. However, I would not call such behaviour an instability. I once heard on a user conference John Fultz of WRI remark about this issue. WRI knows about that, and certainly would like to do something about that, I understand. However, from his remarks I also understood that this is not as easy as one might expect. I am not a system's programmer, and therefore not able to judge on that. Michael Am 23.07.2012 07:05, schrieb Ralph Dratman: > Michael, > > I understand your point about "bad programming," but must respectfully > disagree. I am only asking that the front end remain responsive to a > user interrupt, no matter what else happens. It already has a very > nice menu item to stop evaluation. Why should such a command ever > fail, or be shown as disabled? > > This is not magic, but ordinary system-level programming. It may > amount to just a few hundred lines of code, causing no loss of > performance whatsoever. There are probably a dozen technical people at > Wolfram who are perfectly capable of fixing the problem. > > Anyway, perhaps I am not being quite as harsh or negative as you > think. A bit of direct talk is necessary in this case. I would not be > writing anything at all if I did not like Mathematica as much as I do. > > Ralph > > > > On 19/07/2012 08:51, Michael Weyrauch wrote: >>> Ralph, >>> >>> I really would like to understand your critical remarks somewhat >>> better. >>> >>> It is clear that one can easily and quickly run the frontend irresponsive. >>> However, in most cases I know, this is actually due to bad programming >>> (from Mathematica's point of view) rather than an instable product. >>> >>> One typical reason is that a command returns symbolic results where the >>> programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended? >>> >>> It is the tremendous flexibility and the many possibilities which >>> sometims get into the way, and as a consequence the frontend can not >>> handle the output from the kernel any more. >>> >>> I really do not understand where you expect Wolfram to get "its act >>> together". My experience tells me: A good Mathematica program may run >>> for days without any instability. But my stupitidy and/or lasy >>> programming can run it against >>> the wall within seconds. Mathematica as such is definitely not unstable. >>> (of course, sometimes there are bugs as with any other major (and minor) >>> software). >>> >>> Michael >
[toc] | [prev] | [next] | [standalone]
| From | Ralph Dratman <ralph.dratman@gmail.com> |
|---|---|
| Date | 2012-07-23 23:55 +0000 |
| Message-ID | <juko91$nvg$1@smc.vnet.net> |
| In reply to | #10869 |
James, In your case I suggest you try reinstalling Mathematica. That might help with the kinds of crashes you describe, which should never happen. Ralph On Mon, Jul 23, 2012 at 1:02 AM, James Stein <mathgroup@stein.org> wrote: > On Sun, Jul 22, 2012 at 1:31 AM, David Bailey <dave@removedbailey.co.uk>wrote: > >> >> I am not sure it is always as simple as just blaming the user! I have >> seen Mathematica hang when all I have done is start it up and look >> something up in the help system (or try to). >> > > I also have seen the bad behavior Dave reports, in two guises: > (a) launch mathematica, and it hangs (before, I think, showing the splash screen). > (b) launch Mathematica, access help system, and it hangs while "formatting". > (On a Macintosh, fwiw)
[toc] | [prev] | [next] | [standalone]
| From | Ralph Dratman <ralph.dratman@gmail.com> |
|---|---|
| Date | 2012-07-25 06:32 +0000 |
| Message-ID | <juo3t8$15l$1@smc.vnet.net> |
| In reply to | #10869 |
Yves, Do you know any way to prevent the insertion of code classified as "dynamic"? I don't knowingly use any code of that kind, yet I frequently see a message to the effect that my notebook contains "unsafe" dynamic content! Ralph On Fri, Jul 20, 2012 at 3:48 AM, Yves Klett <yves.klett@googlemail.com> wrote: > Michael, > > the subjective stability changed brutally between versions 5 and 6 with > the introduction of the whole dynamic frontend stuff. With version 6 and > all the very desirable interactivity the number of kernel kills rocketed > for me. > > If you use this heavily there are often hangs/crashes that seem > difficult to reproduce. Sometimes it works, sometimes it does not. Which > can be quite vexing. Of course this may still be due to bad programming, > but in a rather non-deterministic fashion. > > Regards, > Yves > > Am 19.07.2012 09:51, schrieb Michael Weyrauch: >> Ralph, >> >> I really would like to understand your critical remarks somewhat >> better. >> >> It is clear that one can easily and quickly run the frontend irresponsive. >> However, in most cases I know, this is actually due to bad programming >> (from Mathematica's point of view) rather than an instable product. >> >> One typical reason is that a command returns symbolic results where the >> programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended? >> >> It is the tremendous flexibility and the many possibilities which >> sometims get into the way, and as a consequence the frontend can not >> handle the output from the kernel any more. >> >> I really do not understand where you expect Wolfram to get "its act >> together". My experience tells me: A good Mathematica program may run >> for days without any instability. But my stupitidy and/or lasy >> programming can run it against >> the wall within seconds. Mathematica as such is definitely not unstable. >> (of course, sometimes there are bugs as with any other major (and minor) >> software). >> >> Michael >> >> >> Am 15.07.2012 10:28, schrieb Ralph Dratman: >>> David, >>> >>> "Troublesome" puts the matter rather tactfully. >>> >>> Bluntly, there is no excuse for a major product to display such a >>> level of instability in 2012. >>> >>> Since I personally like Mathematica so much, and because I use it >>> constantly, I find the crashes to be both an embarrassment and a >>> disappointment. >>> >>> I can only hope Wolfram Research will soon get its act together on >>> this critically important issue. >>> >>> Ralph >>> >>> >>> On Sat, Jul 14, 2012 at 1:28 AM, David Bailey <dave@removedbailey.co.uk> wrote: >>>> On 12/07/2012 10:00, Yves Klett wrote: >>>>> In earlier incarnations, the kernel would show up as a separate entry in >>>>> the taskbar (on Win XP, that was), which made it very convenient to >>>>> kill. I kind of miss that behaviour (when things go wrong repeatedly). >>>> >>>> I wrote a C program that executes the command >>>> >>>> c:\windows\System32\taskkill.exe /im MathKernel.exe /t /f >>>> >>>> This runs in the background all the time, and responds to a hot key! >>>> >>>> The fact that I took time to set this up, probably reflects just how >>>> troublesome kernel hangs can be! >>>> >>>> Perhaps at the very least Mathematica could spawn a program of this type. >>>> >>>> David Bailey >>>> http://www.dbaileyconsultancy.co.uk >>>> >>>> >>> >> >> >
[toc] | [prev] | [next] | [standalone]
| From | Yves Klett <yves.klett@googlemail.com> |
|---|---|
| Date | 2012-07-26 07:32 +0000 |
| Message-ID | <juqrpj$63s$1@smc.vnet.net> |
| In reply to | #11064 |
Ralf, good question - some of the frontend stuff (e.g. rendered graphs) are dynamic objects by default. Perhaps you can make up a minimal notebook and see when that happens. The gamut of "dynamic content" may also be wider than literally dynamic code... Perhaps someone in the know can chime in here? In a vague kind of way this thread may be related: http://mathematica.stackexchange.com/questions/8357/security-of-mathematica-demonstrations Regards, Yves Am 25.07.2012 08:32, schrieb Ralph Dratman: > Yves, > > Do you know any way to prevent the insertion of code classified as > "dynamic"? I don't knowingly use any code of that kind, yet I > frequently see a message to the effect that my notebook contains > "unsafe" dynamic content! > > Ralph > > > On Fri, Jul 20, 2012 at 3:48 AM, Yves Klett <yves.klett@googlemail.com> wrote: >> Michael, >> >> the subjective stability changed brutally between versions 5 and 6 with >> the introduction of the whole dynamic frontend stuff. With version 6 and >> all the very desirable interactivity the number of kernel kills rocketed >> for me. >> >> If you use this heavily there are often hangs/crashes that seem >> difficult to reproduce. Sometimes it works, sometimes it does not. Which >> can be quite vexing. Of course this may still be due to bad programming, >> but in a rather non-deterministic fashion. >> >> Regards, >> Yves >> >> Am 19.07.2012 09:51, schrieb Michael Weyrauch: >>> Ralph, >>> >>> I really would like to understand your critical remarks somewhat >>> better. >>> >>> It is clear that one can easily and quickly run the frontend irresponsive. >>> However, in most cases I know, this is actually due to bad programming >>> (from Mathematica's point of view) rather than an instable product. >>> >>> One typical reason is that a command returns symbolic results where the >>> programmer actually expected only numerical stuff, and quickly things get completely out of hand. But how should Mathematica know that all this was not intended? >>> >>> It is the tremendous flexibility and the many possibilities which >>> sometims get into the way, and as a consequence the frontend can not >>> handle the output from the kernel any more. >>> >>> I really do not understand where you expect Wolfram to get "its act >>> together". My experience tells me: A good Mathematica program may run >>> for days without any instability. But my stupitidy and/or lasy >>> programming can run it against >>> the wall within seconds. Mathematica as such is definitely not unstable. >>> (of course, sometimes there are bugs as with any other major (and minor) >>> software). >>> >>> Michael >>> >>> >>> Am 15.07.2012 10:28, schrieb Ralph Dratman: >>>> David, >>>> >>>> "Troublesome" puts the matter rather tactfully. >>>> >>>> Bluntly, there is no excuse for a major product to display such a >>>> level of instability in 2012. >>>> >>>> Since I personally like Mathematica so much, and because I use it >>>> constantly, I find the crashes to be both an embarrassment and a >>>> disappointment. >>>> >>>> I can only hope Wolfram Research will soon get its act together on >>>> this critically important issue. >>>> >>>> Ralph >>>> >>>> >>>> On Sat, Jul 14, 2012 at 1:28 AM, David Bailey <dave@removedbailey.co.uk> wrote: >>>>> On 12/07/2012 10:00, Yves Klett wrote: >>>>>> In earlier incarnations, the kernel would show up as a separate entry in >>>>>> the taskbar (on Win XP, that was), which made it very convenient to >>>>>> kill. I kind of miss that behaviour (when things go wrong repeatedly). >>>>> >>>>> I wrote a C program that executes the command >>>>> >>>>> c:\windows\System32\taskkill.exe /im MathKernel.exe /t /f >>>>> >>>>> This runs in the background all the time, and responds to a hot key! >>>>> >>>>> The fact that I took time to set this up, probably reflects just how >>>>> troublesome kernel hangs can be! >>>>> >>>>> Perhaps at the very least Mathematica could spawn a program of this type. >>>>> >>>>> David Bailey >>>>> http://www.dbaileyconsultancy.co.uk >>>>> >>>>> >>>> >>> >>> >> >
[toc] | [prev] | [standalone]
Back to top | Article view | comp.soft-sys.math.mathematica
csiph-web