report from the 1992 Mathematica Conference
- To: mathgroup at yoda.physics.unc.edu
- Subject: report from the 1992 Mathematica Conference
- From: gaylord at ux1.cso.uiuc.edu
- Date: Mon, 1 Jun 1992 11:59:53 -0500
i just got back from the 1992 Mathematica conference in Boston and will try
to find time this week to post about some of the stuff that was shown and
discussed at the conference (forthcoming books on Mathematica [there's a
bunch], future features in the program [really neat things] , etc.).
summary of my impression of the meeting: first rate facilities and hotel,
really lousy dinner at the computer museum, terrific short courses and
tutorials (lots on programming), marginal q&a sessions and forums,
excellent keynote speakers. high quality participants.
and now, the all-important annual programming competition.
the problem was pretty easy so rather than state it, i'll just post the two
solutions judged as best and let you figure out the question.
Mysteryfunction[lis_List] := Union[Rest[FoldList[Max, 1, lis]]]
Mysterypattern[lis_List] := lis//.{a___,x_, y_,b___}/;y<=x -> {a,x,b}
==================================================
before you make your own judgement as to which of these entries deserved to
win the competition for elegance in a program, why don't you guess which
one actually did win?
but wait... before you guess, you might want to remember that the solution
for runEncode that won the competition last year (or the year before, I
forget which) was
runEncode[x_List] :=
Map[({#, 1})&,x]//.{u___,{v_,r_},{v_,s_},w___}->{u,{v,r+s},w}
okay now you can guess.
right. Mysterypattern won the contest.
do you detect an 'pattern' emerging in the judging of the contest?
well at least the functional people (who got robbed in the elegeance
competition) won the efficiency competion. its obvious that the functional
program totally blows away the repeat replacement pattern matching program
in speed.
z = Table[Random[Integer,{1,100}], {100}];
{Timing[Mysteryfunction[z];], Timing[Mysterypattern[z];]}
{{0.05 Second, Null}, {0.483333 Second, Null}}
z = Table[Random[Integer,{1,100}], {200}];
{Timing[Mysteryfunction[z];], Timing[Mysterypattern[z];]}
{{0.0833333 Second, Null}, {3.9 Second, Null}}
z = Table[Random[Integer,{1,100}], {500}];
{Timing[Mysteryfunction[z];], Timing[Mysterypattern[z];]}
{{0.25 Second, Null}, {17.15 Second, Null}}
-----------------
suggestions for next year (anyone at WRI listening ?):
1. divide the contest into different programming style categories such as
best functional program, best pattern-matching program, best rule-based
program (also possibly have different problems in each category).
that way, we won't be subject to the stylistic biases of the judge(s)
[also get some judges whose aesthetic sensibilities extend beyond the
greetings inside Hallmark cards and paintings of elvis on velvet (just
kidding)].
2. don't make efficiency a separate category; efficiency should be one of
the factors considered in determining elegance.
-----------------------------------------
got to go pick up a new puppy. more reports on the meeting will follow as
time permits.
p.s.
i got a lot of e-mail back on my comment about the 'little' Maple language
which i was able to read after the flames died down and the messages
cooled off.
apparently there's not a consensus as to what it means to be a little
language as opposed to a general purpose language.
the definition that i used (and which i got more-or-less from a cs book by
Appleby) is: a little language is used only by the users of the program in
which the language is available AND is used only within the scope of that
program.
obviously there's not going to be anything gained by discussing the
comparative merits of the two languages (or 3 if you count Macsyma or 4 if
you include Axiom) until we get someone who is an unbiased expert on both
languages and not just one or the other.
richard j. gaylord, university of illinois, gaylord at ux1.cso.uiuc.edu
"if you're not programming functionally, then you're programming
dysfunctionally"