Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.soft-sys.math.mathematica > #13103 > unrolled thread
| Started by | amzoti <amzoti@gmail.com> |
|---|---|
| First post | 2013-01-12 03:23 +0000 |
| Last post | 2013-02-26 06:09 +0000 |
| Articles | 20 on this page of 64 — 18 participants |
Back to article view | Back to comp.soft-sys.math.mathematica
Mathematica and Lisp amzoti <amzoti@gmail.com> - 2013-01-12 03:23 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-01-13 02:51 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-14 05:01 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-01-15 04:28 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-17 04:15 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-01-18 05:49 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-22 07:40 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-01-23 04:18 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-24 06:17 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-25 06:33 +0000
Re: Mathematica and Lisp Murray Eisenberg <murray@math.umass.edu> - 2013-01-26 06:37 +0000
Re: Mathematica and Lisp Murray Eisenberg <murray@math.umass.edu> - 2013-01-26 06:37 +0000
Re: Mathematica and Lisp "W. Craig Carter" <ccarter@MIT.EDU> - 2013-01-26 21:58 +0000
Re: Mathematica and Lisp Murray Eisenberg <murray@math.umass.edu> - 2013-01-16 06:39 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-17 04:14 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-01-17 04:14 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@eecs.berkeley.edu> - 2013-01-18 05:50 +0000
Re: Mathematica and Lisp W Craig Carter <ccarter@MIT.EDU> - 2013-01-18 05:50 +0000
Re: Mathematica and Lisp Murray Eisenberg <murray@math.umass.edu> - 2013-01-18 05:50 +0000
Re: Mathematica and Lisp Murray Eisenberg <murray@math.umass.edu> - 2013-01-18 05:49 +0000
Re: Mathematica and Lisp W Craig Carter <ccarter@MIT.EDU> - 2013-01-18 05:49 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-02-01 01:46 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-02 06:15 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-03 07:52 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-05 08:06 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-06 10:52 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-07 02:28 +0000
Re: Mathematica and Lisp danl@wolfram.com - 2013-02-02 06:15 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-03 07:51 +0000
Re: Mathematica and Lisp Andrzej Kozlowski <akozlowski@gmail.com> - 2013-02-03 07:52 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-05 08:06 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-06 10:52 +0000
Palette problem with Feynman slash notation "Dave Snead" <dsnead6@charter.net> - 2013-02-08 10:10 +0000
Re: Mathematica and Lisp Matthias Bode <lvsaba@hotmail.com> - 2013-02-04 01:19 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-02-04 01:20 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-06 06:51 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-06 10:52 +0000
Re: Mathematica and Lisp "mathgroup " <fizzymath@knology.net> - 2013-02-07 02:27 +0000
Re: Mathematica and Lisp Alex Krasnov <akrasnov@eecs.berkeley.edu> - 2013-02-05 03:23 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-02-07 02:28 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-08 10:10 +0000
Re: Mathematica and Lisp ?iso-8859-1?Q?J=E1nos_L=F6bb?= <janos@lobb.com> - 2013-02-09 05:42 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@eecs.berkeley.edu> - 2013-02-09 05:43 +0000
Re: Mathematica and Lisp Andrzej Kozlowski <akozlowski@gmail.com> - 2013-02-08 10:10 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-02-08 10:10 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-09 05:43 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-10 08:34 +0000
Re: Mathematica and Lisp Matthias Bode <lvsaba@hotmail.com> - 2013-02-09 05:43 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-02-15 06:56 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-17 09:08 +0000
Re: Mathematica and Lisp Joe Gwinn <joegwinn@comcast.net> - 2013-02-18 10:59 +0000
Re: Mathematica and Lisp "djmpark" <djmpark@comcast.net> - 2013-02-18 11:00 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-22 06:05 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-23 12:01 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-24 04:31 +0000
Re: Mathematica and Lisp David Bailey <dave@removedbailey.co.uk> - 2013-02-25 07:19 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-26 06:09 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-13 02:51 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-01-16 06:38 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-01-17 04:15 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-01-18 05:50 +0000
Re: Mathematica and Lisp Peter Klamser <klamser@googlemail.com> - 2013-02-24 04:31 +0000
Re: Mathematica and Lisp Richard Fateman <fateman@cs.berkeley.edu> - 2013-02-25 07:19 +0000
Re: Mathematica and Lisp John Doty <noqsiaerospace@gmail.com> - 2013-02-26 06:09 +0000
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
| From | W Craig Carter <ccarter@MIT.EDU> |
|---|---|
| Date | 2013-01-18 05:49 +0000 |
| Message-ID | <kdanpd$39m$1@smc.vnet.net> |
| In reply to | #13161 |
On Jan 17, 13, at 12:14 PM, Richard Fateman wrote: > On 1/15/2013 10:39 PM, Murray Eisenberg wrote: >> On Jan 14, 2013, at 11:31 PM, David Bailey <dave@removedbailey.co.uk.math.umass.edu> wrote: >> >> >> >> It all depends on just what you want somebody to accomplish when learning his/her first programming language. > > There are several issues here. > For a starter, 4-year colleges generally do not offer credit for "a > course to teach you to program in language X" in a department of > computer science. > There may be such courses in physics, statistics, etc departments, > but this should be classified as a utility course, akin to "how to use > the microwave oven in the lunchroom". Was this analogy meant to be pejorative? I teach such a course and receive current and a posteriori feedback on the benefits of learning to rapidly construct a model, compute it, and visualize it. Equally important, the students learn math and a means to acquire more math on their own---and quickly. I teach fundamental concepts of my discipline by using novice programming, numerical analysis, symbolic algebra: voila, canonical discipline knowledge and transferable skills in one course. The "microwave usage" analogy diminishes the importance of an indispensable tool to an applied scientist or engineer. I have physical science colleagues who consider programing and linear algebra to be superfluous because they use spreadsheet tools. I consider their myopic view marginally more perverse than (paraphrasing) `classifying computer language tools as microwave ovens for those who don't build microwaves or understand their operating principles'.
[toc] | [prev] | [next] | [standalone]
| From | John Doty <noqsiaerospace@gmail.com> |
|---|---|
| Date | 2013-02-01 01:46 +0000 |
| Message-ID | <kef6pb$k9a$1@smc.vnet.net> |
| In reply to | #13124 |
On Tuesday, January 22, 2013 2:40:17 AM UTC-5, Richard Fateman wrote: > I rarely write programs of any length in Mathematica, because (as I've > > said) I hold the programming language in generally low regard. > > On the other hand I am pretty much familiar with the language because > > I wrote a parser for it (in Lisp) some time ago, and in my experience > > one of the best ways to really learn a language is to "implement" it. That's crazy. Implementing a language teaches you nothing about its true strengths and weaknesses. To learn that, you must *use* it for real-world problems, not the toy problems of theoretical computer science. > It is also useful for finding high-precision values of numerical > > library functions to compare to other programs, e.g. Bessel functions, > > that I was experimenting with. Unfortunately for Mathematica, I found > > bugs in > > its Bessel function (reported and acknowledged by them). > > Here's one in version 8 (I do not yet have version 9 installed) > > q=429515858585961022071539/6922263581864661506963; > > > > a=N[BesselJ[0,q],45]; > > b=N[BesselJ[0,q],100]; > > c=N[BesselJ[0,q],45]; > > > > a==c > > returns False. Discovering and reporting this kind of bug is useful, but you're still in the realm of toy problems. Such bugs exist in many useful codes, and are only a minor source of error. SPICE3 has been around for about a quarter of a century, and has been critical to billions of dollars of electronic design efforts. Nevertheless, I found and reported a bug in a SPICE3 variant last week. "All non-trivial software has bugs". > If I were using a computer to do something that required correct answers > > for, say, life safety, like building a bridge, I would follow WRI's > > advice and not use Mathematica. I use Mathematica in the creation of designs for space flight hardware. But, of course, I don't *only* use Mathematica. It's most useful for exploring ideas ahead of detailed analysis with more specialized software. But in my business counting on unverified calculation, regardless of the source, is asking for trouble.
[toc] | [prev] | [next] | [standalone]
| From | Richard Fateman <fateman@cs.berkeley.edu> |
|---|---|
| Date | 2013-02-02 06:15 +0000 |
| Message-ID | <keiau5$qqi$1@smc.vnet.net> |
| In reply to | #13327 |
On 1/31/2013 5:46 PM, John Doty wrote:
....
>> (RJF WROTE)
>> I wrote a parser for it (in Lisp) some time ago, and in my experience
>>
>> one of the best ways to really learn a language is to "implement" it.
>
>(JD WROTE) That's crazy. Implementing a language teaches you nothing
> about its true strengths and weaknesses. To learn that, you must
>*use* it for real-world problems, not the toy problems of theoretical
> computer science.
You miss the point. Let me try to clarify this. Mathematica consists
of several parts. Among these:
a specialized language and implementation of a graphics package.
an implementation of routines for Solve, Reduce, Eliminate.
an expression "simplifier" e.g. FullSimplify and friends.
an implementation of significance arithmetic (bigfloats).
....
There is also a programming language, which appears to have no separable
name and so it too seems to be called Mathematica. One can imagine
this language stripped of all the application stuff specific to
mathematics. Apparently Stephen Wolfram has thought about how this
could be separately sold, though has refrained, so far as I know,
from actually doing this.
This programming language has features, none of which would be called
theoretical computer science by a computer scientist.
Of these features there are many that the vast majority
of users are either unaware of, or misunderstand. This is
probably typical for programming languages and naive users.
In addition to the mysteries of the math application and its implementation,
some of Mathematica's LANGUAGE features are non-obvious and
the misunderstanding is promoted by overly-simplified "explanations"
in the documentation. In some cases the obvious and plausible
understanding for an expert in programming languages, based on
an understanding of what other languages do, is wrong. Now such an
expert might venture to say that such "features" were bugs and should
be corrected.
But one learns that sometimes putting a hat and a
beard on a bug makes it into a feature.
As an example, compare Module and Block. Do you think you
really understand Hold, Defer, Evaluate, UpSetDelayed? Do
you think that I do, after implementing them? (Actually, I did
not implement Defer, which was introduced in version 5.0)
For purposes of discussion here I would
include in the programming language the surface syntax and internal
representation of programs, the fundamental parts of naming, binding,
function evaluation, matching, and integer arithmetic.
I expect that few programmers, even if they have written pages of code,
understand all the binding rules and evaluation orders for Rules and
Functions and matching and such.
Often it does not matter if you have an unlimited store of different
names, and never use the same name twice. But sometimes it does matter,
and people write to this newsgroup with mysterious code.
>
>
<snip>
RJF reports a bug, in version 8, not version 9.
>>
>> returns False.
>
> (JD writes)
> Discovering and reporting this kind of bug is useful, but you're still in the realm of toy problems.
> Such bugs exist in many useful codes, and are only a minor source of error.
Well, there are 3 ways reading this.
1. You are unlikely to encounter this bug.
or
2. If you encounter this bug, it will bother you only in a
minor way.
or
3. Most programs have bugs and it doesn't matter.
regarding 1. Read about the Therac-25, in which a bad software
design was implemented, It hardly affected anyone who was treated
with that X-ray machine. It only killed 3 people.
regarding 2. Read about how arithmetic failure, specifically
the conversion of a 64-bit floating point quantity to a 16-bit
signed integer caused the crash of an Ariane 5 rocket, losing
$500 million. Fortunately unmanned.
For more examples, see
http://www.ima.umn.edu/~arnold/disasters/disasters.html
regarding 3. Programming languages with mysterious and undocumented
semantics (as well as poor debugging features) are likely to make
validation more difficult than otherwise.
>
> SPICE3 has been around for about a quarter of a century, and has been
>critical to billions of dollars of electronic design efforts.
Nevertheless,
>I found and reported a bug in a SPICE3 variant last week. "All
non-trivial software has bugs".
This does not seem to me to justify either a bad programming language
design or bugs in Mathematica.
SPICE was, incidentally, developed at Berkeley in my department.
>
>> (RJF) If I were using a computer to do something that required correct answers
>> for, say, life safety, like building a bridge, I would follow WRI's
>> advice and not use Mathematica.
>
> (JD) I use Mathematica in the creation of designs for space flight hardware.
>But, of course, I don't *only* use Mathematica. It's most useful for
exploring
>ideas ahead of detailed analysis with more specialized software.
>But in my business counting on unverified calculation, regardless of
the source,
>is asking for trouble.
If you find Mathematica useful, fine. If you were using it to (for
example) generate code for real-time embedded processors for space
flight controllers, I would hope you would be very aware of the Ariane 5
and similar disasters.
There is, however, an underlying issue here. That is, it is somehow OK
for Mathematica to have bugs because -- its result would be
independently verified, when it matters.
Imagine someone doing some speculative computation in Mathematica, and
exploring some actually non-existent physical phenomenon which was
predicted because of numerical errors.
Perhaps you are familiar with such controversies regarding computer
simulations and Reynold's numbers.
This is not my area of expertise, but is perhaps within yours.
I just googled and found
"Computing high-Reynolds-number turbulence: will simulations ever
replace experiments?"
http://torroja.dmt.upm.es/pubs/2003/jimenez_jot_2003.pdf
This is pretty far afield from the original question which I
think was somehow...s Mathematica somehow Lisp-like.... should I learn Lisp...
Anyone can obviously use whatever tools float your boat/rocket ship.
To make a plausible case that you are using an especially
good "programming language" and should/should not learn another
seems to call for some comparative evaluation from people who
have appropriate expertise (in programming languages).
Unless the original poster was
also in the space-flight business, your opinion may not be
what he is looking for. I don't know for sure what his
field is, but I expect ... It's not rocket science :)
RJF
[toc] | [prev] | [next] | [standalone]
| From | David Bailey <dave@removedbailey.co.uk> |
|---|---|
| Date | 2013-02-03 07:52 +0000 |
| Message-ID | <kel4v7$394$1@smc.vnet.net> |
| In reply to | #13332 |
On 02/02/2013 06:15, Richard Fateman wrote: >>> (RJF) If I were using a computer to do something that required correct answers >>> for, say, life safety, like building a bridge, I would follow WRI's >>> advice and not use Mathematica. >> I'd love to know what software you would use, if you wanted to do a complex calculation of the type we are talking about. What software would meet your standards? David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | Richard Fateman <fateman@cs.berkeley.edu> |
|---|---|
| Date | 2013-02-05 08:06 +0000 |
| Message-ID | <keqei3$ers$1@smc.vnet.net> |
| In reply to | #13350 |
On 2/2/2013 11:52 PM, David Bailey wrote: > On 02/02/2013 06:15, Richard Fateman wrote: > >>>> (RJF) If I were using a computer to do something that required correct answers >>>> for, say, life safety, like building a bridge, I would follow WRI's >>>> advice and not use Mathematica. >>> > > I'd love to know what software you would use, if you wanted to do a > complex calculation of the type we are talking about. What software > would meet your standards? Here are some thoughts, though of course "proving" the correctness of anything, whether a program or a proof of a theorem continues to be an area for research. I'd feel better about using software which had these characteristics: 1. A formal rigorous definition of syntax and semantics. 2. More than one implementation, perhaps one that is open source. 3. Widely available and widely used by top practitioners of (for instance) scientific numerical computation. 4. Perhaps standardized by a committee responsive to the rigors of ANSI or IEEE. 5. Excellent error checking, debugging, profiling tools. I suppose I could think of more. How many of these are lacking in Mathematica? RJF
[toc] | [prev] | [next] | [standalone]
| From | David Bailey <dave@removedbailey.co.uk> |
|---|---|
| Date | 2013-02-06 10:52 +0000 |
| Message-ID | <ketcki$l7v$1@smc.vnet.net> |
| In reply to | #13394 |
On 05/02/2013 08:06, Richard Fateman wrote: > > Here are some thoughts, though of course "proving" the correctness of > anything, whether a program or a proof of a theorem continues to be > an area for research. > I'd feel better about using software which had these characteristics: > > 1. A formal rigorous definition of syntax and semantics. > 2. More than one implementation, perhaps one that is open source. > 3. Widely available and widely used by top practitioners of > (for instance) scientific numerical computation. > 4. Perhaps standardized by a committee responsive to the > rigors of ANSI or IEEE. > 5. Excellent error checking, debugging, profiling tools. > > I suppose I could think of more. > > How many of these are lacking in Mathematica? Well I guess we would all love perfect software, and perfect hardware with infinite performance, but I am really quite curious as to what practical advice you would give to someone with the sort of symbolic/numerical problem that Mathematica is good at - what would you tell them to use? (I don't quite know if mentioning other products in this context is permitted here, but do you even have an existing piece of software in mind?) As regards standardizing committees, I don't think their efforts have always been positive. For example, I would say that Fortran 77 has not been improved by the later standards, that added enormous complexity, and a certain unpredictability in the performance of the more 'advanced' constructs. David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | Richard Fateman <fateman@cs.berkeley.edu> |
|---|---|
| Date | 2013-02-07 02:28 +0000 |
| Message-ID | <kev3fg$pf6$1@smc.vnet.net> |
| In reply to | #13404 |
On 2/6/2013 2:52 AM, David Bailey wrote: > On 05/02/2013 08:06, Richard Fateman wrote: > >> >> Here are some thoughts, though of course "proving" the correctness of >> anything, whether a program or a proof of a theorem continues to be >> an area for research. >> I'd feel better about using software which had these characteristics: >> >> 1. A formal rigorous definition of syntax and semantics. >> 2. More than one implementation, perhaps one that is open source. >> 3. Widely available and widely used by top practitioners of >> (for instance) scientific numerical computation. >> 4. Perhaps standardized by a committee responsive to the >> rigors of ANSI or IEEE. >> 5. Excellent error checking, debugging, profiling tools. >> >> I suppose I could think of more. >> >> How many of these are lacking in Mathematica? > > Well I guess we would all love perfect software, and perfect hardware > with infinite performance, but I am really quite curious as to what > practical advice you would give to someone with the sort of > symbolic/numerical problem that Mathematica is good at - what would you > tell them to use? There are a number of competitors to Mathematica, some free. This would correspond to item 2, sort of. That is, there are other implementations of symbolic math, though not of Mathematica per se. Unfortunately, there are some "bugs" that are system independent -- that is, ALL the authors/programmers fell into the same hole. Therefore it is possible that several systems will agree on the same wrong answer! There are some systems for primarily numerical computation that are far more widespread than Mathematica, corresponding to item 3, at least for numerics. I personally find the debugging facilities in Mathematica to be quite difficult to use. I speculate that it is because the "working model" I have in my mind (and I suspect others share it) is that I am writing programs, composing them in various ways. In reality, the internal evaluation strategy of Mathematica is to apply rules to transform expressions. So while I'm looking for a clue as to which "program" has the bug, the debugging info shows transformations of expressions. This jerking back into the reality of Mathematica's actual nature of evaluation generally prompts me to shy away from the use of Trace. I don't know if it is inevitable, but Trace in particular, and debugging in general in Mathematica seem to me to be quite weak. To the extent that some people might like Mathematica for debugging, it may be that they are comparing it to a non-interactive system (like batch FORTRAN) which will crash and print out a hexadecimal core dump. There is a profiler in the Mathematica Workbench. I have not tried to use it but from the documentation it seems to suffer from the same viewpoint as Trace. It also requires running Mathematica in "debug" mode; I don't know how that affects timings. So in regard to item 5, nearly any alternative system that has an appealing debugging framework. Which would be almost anything that is not bound up in the rule-based paradigm of Mathematica. >(I don't quite know if mentioning other products in > this context is permitted here, but do you even have an existing piece > of software in mind?) > > As regards standardizing committees, I don't think their efforts have > always been positive. Standards vary in usefulness. They can be affected by politics, crazy participants with technical disagreements, etc. The deliberations sometimes are more interesting than the results. For example, there is now an IEEE committee working on interval arithmetic. I do not know if anyone at WRI is on the committee. I expect that Mathematica Intervals will not conform to that standard. Whether this is a positive or negative consequence depends on your viewpoint. > For example, I would say that Fortran 77 has not > been improved by the later standards, that added enormous complexity, > and a certain unpredictability in the performance of the more 'advanced' > constructs. I think the later standards (now FORTRAN 2008 ?) become complicated in part to deal with eventualities that affect real computing circumstances, including (say) newer, standardized floating-point operations [exceptions, etc], multiprocessing, etc. I doubt that anyone approaches the revision of a standard with the goal of increased complexity. It's the consequence of addressing some issue... (I've participated in 4 standards efforts myself.) RJF > > David Bailey > http://www.dbaileyconsultancy.co.uk > >
[toc] | [prev] | [next] | [standalone]
| From | danl@wolfram.com |
|---|---|
| Date | 2013-02-02 06:15 +0000 |
| Message-ID | <keiata$qmi$1@smc.vnet.net> |
| In reply to | #13327 |
On Thursday, January 31, 2013 7:46:19 PM UTC-6, John Doty wrote: > On Tuesday, January 22, 2013 2:40:17 AM UTC-5, Richard Fateman wrote: > > If I were using a computer to do something that required correct answers > > for, say, life safety, like building a bridge, I would follow WRI's > > advice and not use Mathematica. > > I use Mathematica in the creation of designs for space flight hardware > But, of course, I don't *only* use Mathematica. It's most useful for > exploring ideas ahead of detailed analysis with more specialized software. > But in my business counting on unverified calculation, regardless of the > source, is asking for trouble. I will add to this that I am not aware of any such advice from Wolfram Research. The post by RJF had the URL > (see http://www.wolframalpha.com/termsofuse/) This is for Wolfram|Alpha and is mostly irrelevant to Mathematica. I suspect this is the more appropriate legal agreement. http://www.wolfram.com/legal/agreements/wolfram-mathematica.html I believe somewhere the documentation recommends against use for certain types of life-safety applications involving real-time computation. That's not the same thing as designing a bridge, or a jet plane, or landing control software, or medical devices, or drugs, or... Daniel Lichtblau Wolfram Research
[toc] | [prev] | [next] | [standalone]
| From | Richard Fateman <fateman@cs.berkeley.edu> |
|---|---|
| Date | 2013-02-03 07:51 +0000 |
| Message-ID | <kel4ur$390$1@smc.vnet.net> |
| In reply to | #13336 |
On 2/1/2013 10:15 PM, danl@wolfram.com wrote: <snip> > http://www.wolfram.com/legal/agreements/wolfram-mathematica.html > > I believe somewhere the documentation recommends against use for certain types of >life-safety applications involving real-time computation. >That's not the same thing as designing a bridge, or a jet plane, >or landing control software, or medical devices, or drugs, or... > Thanks for the pointer to the right page. If you read it says,under Limited Warranty and Disclaimer "WRI does not recommend the use of the Product for applications in which errors and/or omissions could threaten life, injury, or significant loss. " My comment was, in any case, facetious. Software vendors typically make such disclaimers, though their legal relevance is perhaps questionable if a dispute arises. I am not a lawyer though. RJF
[toc] | [prev] | [next] | [standalone]
| From | Andrzej Kozlowski <akozlowski@gmail.com> |
|---|---|
| Date | 2013-02-03 07:52 +0000 |
| Message-ID | <kel4vd$396$1@smc.vnet.net> |
| In reply to | #13327 |
On 2 Feb 2013, at 07:15, danl@wolfram.com wrote: > On Thursday, January 31, 2013 7:46:19 PM UTC-6, John Doty wrote: >> On Tuesday, January 22, 2013 2:40:17 AM UTC-5, Richard Fateman wrote: > >>> If I were using a computer to do something that required correct answers >>> for, say, life safety, like building a bridge, I would follow WRI's >>> advice and not use Mathematica. >> >> I use Mathematica in the creation of designs for space flight hardware >> But, of course, I don't *only* use Mathematica. It's most useful for >> exploring ideas ahead of detailed analysis with more specialized software. >> But in my business counting on unverified calculation, regardless of the >> source, is asking for trouble. > > I will add to this that I am not aware of any such advice from Wolfram Research. The post by RJF had the URL > >> (see http://www.wolframalpha.com/termsofuse/) > > This is for Wolfram|Alpha and is mostly irrelevant to Mathematica. I suspect this is the more appropriate legal agreement. > > http://www.wolfram.com/legal/agreements/wolfram-mathematica.html > > I believe somewhere the documentation recommends against use for certain types of life-safety applications involving real-time computation. That's not the same thing as designing a bridge, or a jet plane, or landing control software, or medical devices, or drugs, or... > > Daniel Lichtblau > Wolfram Research > > RFJ has been posting this and all his other comments periodically for about a quarter century now so obviously it would be unreasonable to expect him to bother about such fine distinctions like those between WolframAlpha or Mathematica, real-time computation or designing a bridge etc, etc. He also claims to be an "expert" of on the Mathematica language on the basis of having written a Lisp parser for version 2 (or was it 1?) and one that no serious Mathematica users are known to have ever used or tested. Unfortunately, on the rare occasions when he gets involved in discussing some finer points of the Mathematica language his "expertise" turns out to be shaky, as anyone can verify by searching through the archives of this list. So the situation is rather like someone claiming be an expert on the Russian language on the basis of having translated Slovo O Polku Igorevie into Swahili, while his practical knowledge appears to be on the level of http://www.shokhirev.com/nikolai/lang/RussianIn33min.html Andrzej Kozlowski
[toc] | [prev] | [next] | [standalone]
| From | Richard Fateman <fateman@cs.berkeley.edu> |
|---|---|
| Date | 2013-02-05 08:06 +0000 |
| Message-ID | <keqehu$erq$1@smc.vnet.net> |
| In reply to | #13351 |
On 2/2/2013 11:52 PM, Andrzej Kozlowski wrote: . >> >> http://www.wolfram.com/legal/agreements/wolfram-mathematica.html >> > > RFJ has been posting this... Here is the quote, clipped from the mathematica (not wolfram alpha) legal agreement: WRI, and its agents, representatives, and independent contractors, shall not be obligated to provide or liable, under any circumstances, for providing information on or corrections to errors and/or omissions discovered at any time in the Product, whether or not they were aware of the errors and/or omissions. WRI does not recommend the use of the Product for applications in which errors and/or omissions could threaten life, injury, or significant loss. Some states do not allow the exclusion of implied warranties, so this may not apply to You. This warranty gives You specific legal rights, and You may also have other rights that vary from state to state. This Agreement is governed by the laws of the State of Illinois in the United States of America without effect to any choice of law provisions. .......... see the middle of line 5. I believe the parser corresponds to the language of version 3. However, many of the peculiarities of the language are present in version 1. My comments stand on their own, and I think anyone reading them can make his or her own conclusions about their validity. RJF
[toc] | [prev] | [next] | [standalone]
| From | David Bailey <dave@removedbailey.co.uk> |
|---|---|
| Date | 2013-02-06 10:52 +0000 |
| Message-ID | <ketckt$l83$1@smc.vnet.net> |
| In reply to | #13393 |
On 05/02/2013 08:06, Richard Fateman wrote: > On 2/2/2013 11:52 PM, Andrzej Kozlowski wrote: > . >>> >>> http://www.wolfram.com/legal/agreements/wolfram-mathematica.html >>> >> >> RFJ has been posting this... > > Here is the quote, clipped from the mathematica (not wolfram alpha) > legal agreement: > > WRI, and its agents, representatives, and independent contractors, shall > not be obligated to provide or liable, under any circumstances, for > providing information on or corrections to errors and/or omissions > discovered at any time in the Product, whether or not they were aware of > the errors and/or omissions. WRI does not recommend the use of the > Product for applications in which errors and/or omissions could threaten > life, injury, or significant loss. Some states do not allow the > exclusion of implied warranties, so this may not apply to You. This > warranty gives You specific legal rights, and You may also have other > rights that vary from state to state. This Agreement is governed by the > laws of the State of Illinois in the United States of America without > effect to any choice of law provisions. > > .......... > see the middle of line 5. > > > > I believe the parser corresponds to the language of version 3. > However, many of the peculiarities of the language are present in > version 1. > > My comments stand on their own, and I think anyone reading them > can make his or her own conclusions about their validity. > I just hope you never need any prescription medicine of any kind, because if you do, you will find the box contains a list of possible unpleasant side effects. These vary in severity, up to but not exceeding death! All that your quote demonstrates, is that we live in an absurdly litigious culture! David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | "Dave Snead" <dsnead6@charter.net> |
|---|---|
| Date | 2013-02-08 10:10 +0000 |
| Subject | Palette problem with Feynman slash notation |
| Message-ID | <kf2ivf$3ob$1@smc.vnet.net> |
| In reply to | #13393 |
Hi,
The following code creates a palette for Feynman slash notation.
The palette looks OK with slashes through the letters.
However when I click on a button to put the symbol in a document,
the slash is absent. Anybody see what's wrong?
CreatePalette[
Grid[Partition[
PasteButton[
Style[If[# === "", "", Overlay[{#, Style["/", Bold]}]], 12],
RawBoxes[#], ImageSize -> 24, Enabled -> # =!= "" ] & /@ {"a",
"b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n",
"o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z",
"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",
"N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y",
"Z", "", "", ""}, 5], Spacings -> {0, 0}]];
Thanks in advance,
Dave Snead
[toc] | [prev] | [next] | [standalone]
| From | Matthias Bode <lvsaba@hotmail.com> |
|---|---|
| Date | 2013-02-04 01:19 +0000 |
| Message-ID | <ken2br$7f6$1@smc.vnet.net> |
| In reply to | #13124 |
Hola: The fact that WRI does not even "recommend the use of the Product" in instances where it could "threaten" ... "injury, or significant loss" does indeed constitute a most serious limitation to "the Product's" usefulness. Best regards, MATTHIAS BODE (User since version 2.)S 17.36398=B0, W 66.21816=B0,2'590m. AMSL. > From: fateman@cs.berkeley.edu > Subject: Re: Mathematica and Lisp > To: mathgroup@smc.vnet.net > Date: Sun, 3 Feb 2013 02:46:43 -0500 > > On 2/1/2013 10:15 PM, danl@wolfram.com wrote: > <snip> > > > http://www.wolfram.com/legal/agreements/wolfram-mathematica.html > > > > I believe somewhere the documentation recommends against use for certain types of > >life-safety applications involving real-time computation. > >That's not the same thing as designing a bridge, or a jet plane, > >or landing control software, or medical devices, or drugs, or... > > > > Thanks for the pointer to the right page. If you read it says,under > Limited Warranty and Disclaimer > > "WRI does not recommend the use of the Product for applications in which > errors and/or omissions could threaten life, injury, or significant loss. " > > My comment was, in any case, facetious. Software vendors typically > make such disclaimers, though their legal relevance is perhaps > questionable if a dispute arises. I am not a lawyer though. > > RJF >
[toc] | [prev] | [next] | [standalone]
| From | John Doty <noqsiaerospace@gmail.com> |
|---|---|
| Date | 2013-02-04 01:20 +0000 |
| Message-ID | <ken2c5$7fl$1@smc.vnet.net> |
| In reply to | #13124 |
On Saturday, February 2, 2013 1:15:33 AM UTC-5, Richard Fateman wrote: > On 1/31/2013 5:46 PM, John Doty wrote: > > .... > > > > >> (RJF WROTE) > > >> I wrote a parser for it (in Lisp) some time ago, and in my experience > > >> > > >> one of the best ways to really learn a language is to "implement" it. > > > > > >(JD WROTE) That's crazy. Implementing a language teaches you nothing > > > about its true strengths and weaknesses. To learn that, you must > > >*use* it for real-world problems, not the toy problems of theoretical > > > computer science. > > > > You miss the point. Let me try to clarify this. Mathematica consists > > of several parts. Among these: > > > > a specialized language and implementation of a graphics package. > > an implementation of routines for Solve, Reduce, Eliminate. > > an expression "simplifier" e.g. FullSimplify and friends. > > an implementation of significance arithmetic (bigfloats). > > .... > > > > There is also a programming language, which appears to have no separable > > name and so it too seems to be called Mathematica. One can imagine > > this language stripped of all the application stuff specific to > > mathematics. Apparently Stephen Wolfram has thought about how this > > could be separately sold, though has refrained, so far as I know, > > from actually doing this. > > > > This programming language has features, none of which would be called > > theoretical computer science by a computer scientist. > > Of these features there are many that the vast majority > > of users are either unaware of, or misunderstand. This is > > probably typical for programming languages and naive users. > > > > In addition to the mysteries of the math application and its implementation, > > some of Mathematica's LANGUAGE features are non-obvious and > > the misunderstanding is promoted by overly-simplified "explanations" > > in the documentation. In some cases the obvious and plausible > > understanding for an expert in programming languages, based on > > an understanding of what other languages do, is wrong. Now such an > > expert might venture to say that such "features" were bugs and should > > be corrected. > > But one learns that sometimes putting a hat and a > > beard on a bug makes it into a feature. > > As an example, compare Module and Block. Do you think you > > really understand Hold, Defer, Evaluate, UpSetDelayed? Do > > you think that I do, after implementing them? (Actually, I did > > not implement Defer, which was introduced in version 5.0) Well, I know from private communication that you do *not* understand UpSetDelayed in any useful way, since you don't understand what to use it for. Implementing it has taught you nothing. But if you were to read the dcumentation... > > > > For purposes of discussion here I would > > include in the programming language the surface syntax and internal > > representation of programs, the fundamental parts of naming, binding, > > function evaluation, matching, and integer arithmetic. > > > > I expect that few programmers, even if they have written pages of code, > > understand all the binding rules and evaluation orders for Rules and > > Functions and matching and such. > > > > Often it does not matter if you have an unlimited store of different > > names, and never use the same name twice. But sometimes it does matter, > > and people write to this newsgroup with mysterious code. > > > > > > > > <snip> > > RJF reports a bug, in version 8, not version 9. > > > > >> > > >> returns False. > > > > > > (JD writes) > > > > > > > Discovering and reporting this kind of bug is useful, but you're still in the realm of toy problems. > > > Such bugs exist in many useful codes, and are only a minor source of error. > > > > Well, there are 3 ways reading this. > > > > 1. You are unlikely to encounter this bug. > > or > > 2. If you encounter this bug, it will bother you only in a > > minor way. > > or > > 3. Most programs have bugs and it doesn't matter. > > > > regarding 1. Read about the Therac-25, in which a bad software > > design was implemented, It hardly affected anyone who was treated > > with that X-ray machine. It only killed 3 people. > > > > regarding 2. Read about how arithmetic failure, specifically > > the conversion of a 64-bit floating point quantity to a 16-bit > > signed integer caused the crash of an Ariane 5 rocket, losing > > $500 million. Fortunately unmanned. Considered as software failures, both of these occurred in application code and were not the result of programming language deficiencies. Quite different from your nitpicking. But seeing these as software failures obscures the real issues. All non-trivial software has bugs. In this light, both of these can be seen fundamentally as systems engineering failures. In the Therac-25 case, the engineers had removed a hardware safety interlock that prevented earlier models from operating when dangerously misconfigured. There were other engineering errors, but that was the critical one. Even if the software could be made perfect, a device like the Therac-25 needs such hardware interlocks because computers themselves are not perfectly reliable. At least the Ariane engineers recognized that their computer hardware was not perfectly trustworthy. So, they arranged that if the guidance computer detected a fault in its execution it would halt. Then, hardware would pass control to the backup, which was an identical unit running identical software with identical inputs. Oops. This approach guaranteed that any fault caused by a software bug or hardware design error would automatically shut down all guidance. It makes little sense in this case to blame the specific software bug that triggered the failure: the system was designed to fail. Contrast that with the Apollo LM computer, where software or hardware upset would prompt a restart, with just enough state maintained in hardware to allow the computer to continue controlling the descent. Good, robust engineering: it saved the Apollo 11 landing. In that case, the "bug" was actually in a checklist, but from a systems engineering perspective that's part of the software. > > regarding 3. Programming languages with mysterious and undocumented > > semantics (as well as poor debugging features) are likely to make > > validation more difficult than otherwise. To you, Mathematica is mysterious, because you fight it rather than using it. And you haven't even read the documentation you complain about (if you had, you'd understand what UpSetDelayed is for). I don't find Mathematica to be especially mysterious relative to its capabilities. > > > > > > > > > > > >> (RJF) If I were using a computer to do something that required correct answers > > >> for, say, life safety, like building a bridge, I would follow WRI's > > >> advice and not use Mathematica. > > > > > > (JD) I use Mathematica in the creation of designs for space flight hardware. > > >But, of course, I don't *only* use Mathematica. It's most useful for > > exploring > > >ideas ahead of detailed analysis with more specialized software. > > >But in my business counting on unverified calculation, regardless of > > the source, > > >is asking for trouble. > > > > If you find Mathematica useful, fine. If you were using it to (for > > example) generate code for real-time embedded processors for space > > flight controllers, I would hope you would be very aware of the Ariane 5 > > and similar disasters. I am aware of those, as well as many that you've never heard of. And I have multiple viewpoints from which to understand them. Preventing these is often a matter of several layers of "even-if". "We've verified X, but even if we're wrong, there's Y to prevent disaster. And even if Y fails, Z can takeover." > There is, however, an underlying issue here. That is, it is somehow OK > > for Mathematica to have bugs because -- its result would be > > independently verified, when it matters. Not all bugs are of equal importance. An error of 5.5E-79 in a Bessel function is very unlikely to cause trouble in a practical application. I've been using Mathematica to do practical work since version 1, and I've never encountered a bug in its numerics. > > > > Imagine someone doing some speculative computation in Mathematica, and > > exploring some actually non-existent physical phenomenon which was > > predicted because of numerical errors. Crazy results from numerical codes are a normal occurrance, so the consumer of the results must beware. However, these are rarely due to the programming language or library, whether the code is in Mathematica or some other language. Every non-trivial numerical model depends on incompletely understood assumptions and approximations. Even for a venerable and relatively well-understood code like SPICE3, tuning the integrator parameters is a bit of a black art, and insane results are to be expected if you get those wrong for your circuit. I don't find Mathematica to be unusually hazardous here. > This is pretty far afield from the original question which I > > think was somehow...s Mathematica somehow Lisp-like.... should I learn Lisp... I'm unusual in that I write practical engineering code in Scheme (a Lisp dialect), along with code for both science and engineering in Mathematica. I actually *use* both languages, rather than fighting them, so I think I have a fair amount of insight here. From that viewpoint, I would tell the OP that the resemblance of Mathematica and Lisp is superficial: Mathematica is actually closer to "sed". And perhaps that's the root of your problem as well. Mathematica is not Lisp: Lisp design prejudices are irrelevant. > > > > Anyone can obviously use whatever tools float your boat/rocket ship. > > > > To make a plausible case that you are using an especially > > good "programming language" and should/should not learn another > > seems to call for some comparative evaluation from people who > > have appropriate expertise (in programming languages). Programming language specialists have many interesting ideas, but lousy judgement when it comes to which ones are important in any particular application context. Four decades ago I recall hearing "C's too crude, PL/I is the future". Yeah, right. But "the proof of the pudding is in the eating". If you want to understand the applicability of a language to, say, bridge design, you need to talk to bridge designers who've used it.
[toc] | [prev] | [next] | [standalone]
| From | Richard Fateman <fateman@cs.berkeley.edu> |
|---|---|
| Date | 2013-02-06 06:51 +0000 |
| Message-ID | <kesugu$jv8$1@smc.vnet.net> |
| In reply to | #13365 |
On 2/3/2013 5:20 PM, John Doty wrote: .... You seem to think I haven't written Mathematica programs. Maybe looking at the appendix here would change your mind. Maybe not, though. http://www.cs.berkeley.edu/~fateman/papers/better-rules.pdf (JD writes..) > > Considered as software failures, both of these occurred in application code and were not the result of programming language deficiencies. Was the code not written in a programming language? Even if it was written in assembler, that too is a programming language. I expect that the bug occurred because the programmer did not realize the semantics of the code. >I don't find Mathematica to be especially mysterious relative to its capabilities. Mathematica the language is, I think, relatively mysterious. The application underneath it adds both capabilities and extra mystery. > >> >> (RJF) I would hope you would be very aware of the Ariane 5 >> >> and similar disasters. > > I am aware of those, as well as many that you've never heard of. How would you know that I don't know? Are they secret? > > Not all bugs are of equal importance. An error of 5.5E-79 in a Bessel function is very unlikely >to cause trouble in a practical application. One of the marvels of computing today is that it is possible to do so much in such a short time. One can execute billions of instructions a second. If only one in a million does the wrong thing, and is wrong only by a tiny percent, you can accumulate a whopping mistake in a second. I've been using Mathematica to do practical work since version 1, > and I've never encountered a bug in its numerics. I guess it is my turn to wonder if YOU know much about Mathematica. > > Crazy results from numerical codes are a normal occurrance, >... > I don't find Mathematica to be unusually hazardous here. I guess I disagree on this point. > >> This is pretty far afield from the original question which I >> >> think was somehow...s Mathematica somehow Lisp-like.... should I learn Lisp... > > I'm unusual in that I write practical engineering code in Scheme (a Lisp dialect), > along with code for both science and engineering in Mathematica. I think that is unusual, but I count it as a good thing. Though Common Lisp (a Lisp dialect) is used in space computations -- the Hubble telescope. For more applications, see http://common-lisp.net/~dlw/LispSurvey.html ... > > Programming language specialists have many interesting ideas, > but lousy judgement when it comes to which ones are important >in any particular application context. Somewhat over-generalized, I think. ..... RJF
[toc] | [prev] | [next] | [standalone]
| From | David Bailey <dave@removedbailey.co.uk> |
|---|---|
| Date | 2013-02-06 10:52 +0000 |
| Message-ID | <ketcko$l81$1@smc.vnet.net> |
| In reply to | #13400 |
On 06/02/2013 06:51, Richard Fateman wrote: > > One of the marvels of computing today is that it is possible to do so > much in such a short time. > One can execute billions of instructions a second. If only > one in a million does the wrong thing, and is wrong only > by a tiny percent, you can accumulate a whopping mistake > in a second. > When I have given introductory Mathematica courses, one of the things I would point out early on, was that you should never implicitly trust Mathematica to get an answer that was important to you. By that, I did not mean what you seem to mean - that Mathematica was particularly buggy - because it is not, but every substantial piece of software contains some faults, and fingers contain bugs too - so it is easy to mistakenly type something like: Integrate[Exp[ax]x,x] and be be amazed by the answer. Likewise, systems of equations can be numerically unstable and generate junk. It might almost be better to train students on slightly faulty software to make them more vigilant! David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | "mathgroup " <fizzymath@knology.net> |
|---|---|
| Date | 2013-02-07 02:27 +0000 |
| Message-ID | <kev3f6$pf1$1@smc.vnet.net> |
| In reply to | #13400 |
About your last sentence......." It might almost be better to train students on slightly faulty software to make them more vigilant!" I've often wondered about teaching Science with as much 'wrong' as possible.....How many of the students would actually perk up and say 'hey , wait a minute' instead of just adding more useless information to their notes and brains.... jerry blimbaum -----Original Message----- From: David Bailey Sent: Wednesday, February 06, 2013 4:52 AM Subject: Re: Mathematica and Lisp On 06/02/2013 06:51, Richard Fateman wrote: > > One of the marvels of computing today is that it is possible to do so > much in such a short time. > One can execute billions of instructions a second. If only > one in a million does the wrong thing, and is wrong only > by a tiny percent, you can accumulate a whopping mistake > in a second. > When I have given introductory Mathematica courses, one of the things I would point out early on, was that you should never implicitly trust Mathematica to get an answer that was important to you. By that, I did not mean what you seem to mean - that Mathematica was particularly buggy - because it is not, but every substantial piece of software contains some faults, and fingers contain bugs too - so it is easy to mistakenly type something like: Integrate[Exp[ax]x,x] and be be amazed by the answer. Likewise, systems of equations can be numerically unstable and generate junk. It might almost be better to train students on slightly faulty software to make them more vigilant! David Bailey http://www.dbaileyconsultancy.co.uk
[toc] | [prev] | [next] | [standalone]
| From | Alex Krasnov <akrasnov@eecs.berkeley.edu> |
|---|---|
| Date | 2013-02-05 03:23 +0000 |
| Message-ID | <keptv7$dh8$1@smc.vnet.net> |
| In reply to | #13124 |
On Sun, 3 Feb 2013, John Doty wrote: > All non-trivial software has bugs. Although this statement is somewhere between meaningless and false, the primary issue is not with the presence of bugs in Mathematica but rather with the frequency of bugs as compared to that for programs of similar complexity. Frankly, the effort is better expended on correcting the issue than on arguing about it. > To you, Mathematica is mysterious, because you fight it rather than > using it. I have been using Mathematica for solving a practical problem for several months and am quite happy with it overall. However, it is already obvious from personal experience and numerous reports on this list that quality control at Wolfram Research is at best severely lacking. > I've been using Mathematica to do practical work since version 1, and > I've never encountered a bug in its numerics. Surely, you must be joking. Alex
[toc] | [prev] | [next] | [standalone]
| From | John Doty <noqsiaerospace@gmail.com> |
|---|---|
| Date | 2013-02-07 02:28 +0000 |
| Message-ID | <kev3fr$pfg$1@smc.vnet.net> |
| In reply to | #13124 |
On Wednesday, February 6, 2013 1:51:10 AM UTC-5, Richard Fateman wrote: > On 2/3/2013 5:20 PM, John Doty wrote: > > .... > > You seem to think I haven't written Mathematica programs. > > Maybe looking at the appendix here would change your mind. > > Maybe not, though. > > http://www.cs.berkeley.edu/~fateman/papers/better-rules.pdf All this demonstrates is that you don't understand how to use Mathematica. = All you know how to do is fight against it. You don't understand when to us= e rules versus when to use the various algebraic tools. Your code is pointl= ess: no trajectories calculated, no bridges designed, and it doesn't enable= anything that Mathematica can't already do. > > Considered as software failures, both of these occurred in application = code and were not the result of programming language deficiencies. > > > > Was the code not written in a programming language? > > Even if it was written in assembler, that too is > > a programming language. I expect that the bug > > occurred because the programmer did not realize the > > semantics of the code. In the Theravac case, the coders appeared not to understand the operation a= nd hazards of the radiation therapy machinery very well. In Ariane case, I = have heard that the coders concluded that overflow was impossible in the co= ntext of Ariane IV, but that analysis was not redone for Ariane V when the = software was reused. In any case, the fundamental failure in both cases was= in systems engineering, not code. You shouldn't place much blame on the sp= ark that sets you on fire when you walk around in clothes soaked with gasol= ine. > > Not all bugs are of equal importance. An error of 5.5E-79 in a Bessel f= unction is very unlikely > > >to cause trouble in a practical application. > > > > One of the marvels of computing today is that it is possible to do so > > much in such a short time. > > One can execute billions of instructions a second. If only > > one in a million does the wrong thing, and is wrong only > > by a tiny percent, you can accumulate a whopping mistake > > in a second. 5.5E-79 is rather smaller than a tiny percent. The best physical measuremen= ts are good to a few parts in 10^16. Assuming teraflop arithmetic, adding n= umbers with errors of 5.5E-79, it'll take you about 4E45 times the age of t= he universe to have errors add up to 1E-16. > I've been using Mathematica to do practical work since version 1, > > > and I've never encountered a bug in its numerics. > > I guess it is my turn to wonder if YOU know much about Mathematica. The difference is that I *use* it. You *fight* it. > > Crazy results from numerical codes are a normal occurrence, > > > I don't find Mathematica to be unusually hazardous here. > > I guess I disagree on this point. But you don't actually use numerical codes. You don't design bridges, compu= te trajectories, or study turbulence. So your opinion is uninformed. > >> This is pretty far afield from the original question which I > >> think was somehow...s Mathematica somehow Lisp-like.... should I learn= Lisp... >> > > I'm unusual in that I write practical engineering code in Scheme (a Lis= p dialect), > > along with code for both science and engineering in Mathematica. > > I think that is unusual, but I count it as a good thing. Well, I'm not so sure that using Scheme is so good: it means that few poten= tial collaborators are willing to try to read my code. To the average engin= eer or scientist, Lisp screams "forget your application and pay attention t= o the cool computer science". Now, I actually know enough of that CS crap t= hat I can see past it to reality, but most don't. I primarily use Scheme to= access a collection of useful functions that are actually written in C, bu= t have Scheme (Guile) interfaces. I think it would be much better if those = interfaces were in a language friendlier to engineers, like Python. Scheme'= s fine for me, with my eccentric background, but not for most others. > Though > Common Lisp (a Lisp dialect) is used in space computations -- > the Hubble telescope. My old colleague Mark Johnston developed SPIKE for Hubble, but it has been = and is used for other missions as well. I was involved in getting the ASCA = and Chandra space observatories to adopt it for their operational planning.= The last time I talked to Mark (a long time ago), he seemed rather unhappy= with CL as an implementation language for a practical AI application. I do= n't think he'd choose CL again if he had to rewrite SPIKE.
[toc] | [prev] | [next] | [standalone]
Page 2 of 4 — ← Prev page 1 [2] 3 4 Next page →
Back to top | Article view | comp.soft-sys.math.mathematica
csiph-web