Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]


Groups > comp.soft-sys.math.mathematica > #10869 > unrolled thread

Re: Sending an interrupt to the frontend?

Started byJohn Fultz <jfultz@wolfram.com>
First post2012-07-11 06:18 +0000
Last post2012-07-26 07:32 +0000
Articles 18 — 10 participants

Back to article view | Back to comp.soft-sys.math.mathematica


Contents

  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

#10869 — Re: Sending an interrupt to the frontend?

FromJohn Fultz <jfultz@wolfram.com>
Date2012-07-11 06:18 +0000
SubjectRe: 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]


#10897

FromYves Klett <yves.klett@googlemail.com>
Date2012-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]


#10912

FromDavid Bailey <dave@removedbailey.co.uk>
Date2012-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]


#10944

From"Alexey Popkov" <lehin.p@gmail.com>
Date2012-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]


#10931

FromRalph Dratman <ralph.dratman@gmail.com>
Date2012-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]


#10964

FromDavid Bailey <dave@removedbailey.co.uk>
Date2012-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]


#10984

Fromleigh pascoe <leigh@evry.inserm.fr>
Date2012-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]


#10985

FromMichael Weyrauch <michael.weyrauch@gmx.de>
Date2012-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]


#11023

FromDavid Bailey <dave@removedbailey.co.uk>
Date2012-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]


#10987

FromW Craig Carter <ccarter@MIT.EDU>
Date2012-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]


#10989

FromJames Stein <mathgroup@stein.org>
Date2012-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]


#11037

FromJames Stein <mathgroup@stein.org>
Date2012-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]


#11044

FromGeorge Woodrow III <georgevw3@mac.com>
Date2012-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]


#11041

FromRalph Dratman <ralph.dratman@gmail.com>
Date2012-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]


#11051

FromMichael Weyrauch <michael.weyrauch@gmx.de>
Date2012-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]


#11043

FromRalph Dratman <ralph.dratman@gmail.com>
Date2012-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]


#11064

FromRalph Dratman <ralph.dratman@gmail.com>
Date2012-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]


#11074

FromYves Klett <yves.klett@googlemail.com>
Date2012-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