
Announcing Wolfram Programming Lab - kwvarga
http://blog.wolfram.com/2016/01/19/announcing-wolfram-programming-lab/
======
picozeta
I am not sure Wolfram Research realize what they have.

If they would make their stack FOSS they would be absolute heroes and shape
the future of applied math and computation software with a historic impact.
Otherwise they will fade away, when other interfaces (Jupyter & Co.) catch up
and/or surpass it in its capabilities. More and more people will just not
accept the closed nature as it inherently contradicts with the idea of
exploration.

There are basically 3 scenarios:

\- they go FOSS now: best outcome for people and Wolfram

\- they go FOSS later: good outcome for people, more difficult for Wolfram, as
they lose developers/community

\- the don't go FOSS (or not in near future): Wolfram SW won't be used anymore
as open alternatives surpass it. People won't care.

Even Microsoft got it.

~~~
gaze
I don't really see sympy and the like surpassing Mathematica. Even maple is
kinda having trouble. If when I'm buying Mathematica I'm paying for a proper
implementation of the risch (integration) algorithm, it will have been money
well spent.

~~~
S4M
Doesn't Maxima [0] have a proper implementation of the Risch algorithm
already?

[0] [http://maxima.sourceforge.net/](http://maxima.sourceforge.net/)

~~~
fdej
There is no complete implementation of the Risch algorithm. None of the
implementations fully implement the algebraic case. Besides, the Risch
algorithm doesn't solve all symbolic integration problems in practice:

* Even when it succeeds, it doesn't necessarily give you the simplest possible form of the solution.

* It is concerned with elementary functions, but real-world problem often involve non-elementary functions (like Bessel and hypergeometric functions). You can extend the Risch algorithm to work with such functions, but this is complicated.

* It doesn't allow computing parametric answers for common parametric families of integrals (this needs to be done using heuristics and lookup tables).

* It doesn't give you an algorithm for definite integration, except in simple cases. Even with proper definite integrals, you need to be extremely careful with branch cuts when applying the fundamental theorem of calculus. For improper definite integrals, systems like Mathematica generally try to go via convolutions of Meijer G-functions, using huge lookup tables and simplification heuristics.

* Even more fundamentally, the Risch algorithm (and symbolic integration more generally) puts heavy demands on the underlying symbolic computation engine. In particular, it depends on the ability to decide whether an expression is equivalent to zero, which in fact is an undecidable problem, and this strictly speaking makes the Risch "algorithm" a non-algorithm (though it is a proper algorithm when restricted to a ground field where zero testing is effective, such as Q).

~~~
S4M
I can only say that I am very impressed by the knowledge you are displaying
about the Risch algorithm and symbolic integration. If I may ask, what is your
background and how did you learn about them so deeply?

~~~
fdej
PhD in symbolic computation (RISC). Symbolic integration is not my field of
research, though, and I don't really know anything beyond the basics (covered
in courses on computer algebra). Passively attended plenty of seminars and
conference talks on symbolic integration, though, and for a couple of years, I
did share office with Clemens Raab who is one of the experts on the Risch
algorithm.

~~~
S4M
I am working on a project that requires symbolic computation, which I am
learning a bit by myself. For now I can manage, but could I get in touch with
you in case I would need some advice about that? My email is in my profile
(thanks!).

------
theossuary
I absolutely hate Wolfram's online workbook UI. No matter how careful I am I
end up breaking it in so many ways. Delete that image of a horse? Too bad,
have to refresh the page to get it back. Click enter incorrectly? That new
line can never be deleted now. Want to format your document at all? Good luck.

I subscribed to their online offering when it originally came out, but
immediately canceled because the UI is just so far behind its desktop
competitors, like Maple, and even Matlab. I want to support this software, it
has great potential, but they need to sit down and really rethink how it's put
together and delivered to the user.

~~~
jacobolus
Maple makes me sad. They had an amazingly effective streamlined GUI circa
2000, a native Windows app which launched significantly faster than the built-
in Microsoft calculator tool, and then felt like an upgraded terminal-style
REPL with all of math at your fingertips. It had capable plotting with nice
embedded graphics, great built in documentation with fast search, etc. It was
rock solid, I don’t think I crashed it once. As a high school student, it was
an amazing tool for me.

Then they decided to hop on the Java bandwagon, and rewrote their whole UI
using some kind of cross-platform Java GUI toolkit. App startup time went from
like a tenth of a second to like 30 seconds (at least, that was my subjective
impression at the time). Every part of the GUI was laggy and glitchy, it
crashed regularly, the documentation was reorganized and much more confusing,
etc.

The big-ticket feature additions which supposedly justified the rewrite were
some gimmicky stuff for writing formulas in a more standard-math-typography
way instead of as plain text, plus some related handwriting recognition
thingy, but this ended up being slow, confusing, and ineffective, and
cluttering up the rest of the interface.

~~~
blt
I used a version of Maple that shipped with both the Java GUI and the native
one. It was amazing how much faster the native GUI started and ran.

This was before I learned "real" programming, so I actually stuck with the
Java GUI to get the pretty-printed math formula editor. Still, maybe that
experience caused me to avoid writing Java programs later on...

~~~
pjmlp
However many Java desktop applications are bad, mainly because developers
don't care.

\- No setting of the platform's L&F

\- Everything is done on the main thread

\- No care is taken about how to write GC friendly code and data structures

\- No attention to eye candy

It is like having Assembly developers cry at the shitty performance of C
compilers in the early 80's and blame the language.

------
psyklic
As an experienced developer, I surprisingly enjoyed progressing through
Wolfram's book for beginners. (I used Mathematica, not their online UI.) In
particular:

\+ Making instant web apps and APIs just by specifying two functions --
"front-end" and "back-end".

\+ Easily creating impressive-looking programmatic 2D and 3D graphics and
sounds.

\+ Innovative idea making visible graphics and colors as arguments and outputs
of functions.

\+ "Knowledgebase" of facts accessible using natural language. (Though, this
was often slow due to server calls.)

My main critique of Mathematica is that it is the epitome of a kitchen sink
library. There is an overwhelming number of functions for every possible
thing. So, it is often not feasible to know what is offered without a lot of
reading. (In fact, Wolfram even states this in his book.)

This is the real problem with their "knowledgebase". I would love to enter any
natural-language query and get an answer, but in reality I need to check their
list of supported areas and know the seemingly arbitrary list of facts about
each area. To really make this useful, Wolfram has to figure out how to make
it work without requiring me to be so knowledgeable about what it contains a
priori.

Also, having such a large standard library makes the language very "flashy".
It is indeed impressive and inspiring to create a sphere or musical piece in
one line of code. However, real programs end up being much larger. In
practical programs, Mathematica's functional syntax results in long unwieldy
statements with forced formatting. This is occasionally impressive, but it is
just as often hard to decipher.

~~~
jessriedel
I don't really get the complains about a kitchen sink of predefined functions,
or the functional syntax. You can always fall back on defining a function
yourself. (And with the amazing documentation and Google, it's quite easy to
find most functions anyways.) Likewise, you can always use C++-style syntax
for defining functions, for loops, etc.

Mathematica has plenty of problems, like it's extreme slowness for things that
should be comiled, and awkward reference passing, but the ones you've pointed
out don't really make sense to me.

~~~
JadeNB
> I don't really get the complains about a kitchen sink of predefined
> functions

If you're running it locally, there's a very practical reason to complain:
between Wolfram 7 and 8, the application bundle size went from 29 MB to 2.65
GB. That's not a typo.

~~~
taliesinb
About 70% of storage used by the latest version 10.3.1 is the documentation,
for what that's worth (maybe nothing).

~~~
amk_
This is true for lots of programs. Try installing TeXLive or a similar LaTeX
distribution from a package manager. Usually it pulls in a *-docs package that
takes up well more than half of the download.

~~~
JadeNB
To be fair, though, it is very easy to customise TeXLive so that it _doesn 't_
do this; whereas, as far as I know, Mathematica offers no such option. To be
sure, you can delete it afterwards, but I'm not sure how gracefully
Mathematica deals with that; whereas TeXLive, for example, gracefully deals
with incremental upgrades from a very basic installation. (I know, because
that's exactly how I run it on my tiny SSD. My current installation is well
under 1 GB.)

------
tolmasky
If you'd like a similar experience without being tied to a proprietary
language and where the skills you develop can later be applied to other
fields, I'd like to recommend our [https://tonicdev.com](https://tonicdev.com)
.

It uses JavaScript (support for node 0.10 through 5), and instead of being one
giant library made by one company, connects you to every version of every
package on npm (that's 200,000+ libraries!). Anytime something is published on
npm, it immediately becomes available on tonic, allowing you to work with the
"global standard library". If you use something like D3, you can do math
visualizations: [https://tonicdev.com/tonic/d3-example-from-
beaker](https://tonicdev.com/tonic/d3-example-from-beaker) . Alternatively,
you can use async and await to play with APIs:
[https://tonicdev.com/capicue/iss/4.0.0](https://tonicdev.com/capicue/iss/4.0.0)
. When you're done, you can hit download and run it on your own computer using
node.

------
kriro
Unrelated to the topic at hand but I browsed their site and found this
gem...marketing might want to think about replacing that customer story:

[http://www.wolfram.com/mathematica/customer-
stories/predicti...](http://www.wolfram.com/mathematica/customer-
stories/predicting-mortgage-stability-with-mathematica.html)

"""Fannie Mae financial economist Bernard Gress is taking an innovative
approach to predicting the stability of mortgages. He's using Wolfram
technologies [...]"""

------
icu
My son is only 2 but I hope to pass on to him my love of maths, electronics
and programming in an interactive way. This is why, for example I've been
getting to grips with the raspberry pi and keeping tabs on the whole 'computer
based math' movement. While I understand the background issues some HNers have
with Wolfram I'm cheering on any efforts (including this new Wolfram Labs
announcement) that may spark my son's interest and aid his future education.

~~~
Edmond
check out www.jasymchat.com, not Wolfram but students love it:)

~~~
amk_
If you want to promote your own work and avoid the downvotes, now would be a
good time to do a Show HN.

------
snorrah
Does this cost money..? I remember when the iOS app came out for the
computational engine. For $50. I'm sure that was a long since rued decision to
price it like that, but I still have this odd feeling about Wolfram doing this
fancy stuff but trying to spin a big chunk o dough for it. (Not that it's a
bad thing but I don't see cost talked about here compared to their other
products?)

------
gertef
Mathematica/Wolfram is probably the closest real-world implementation to Bret
Victor's "kill math" vision of experiential programming.

------
dTal
>Wolfram Programming Lab is something that’s uniquely made possible by the
Wolfram Language. Because it’s only with the whole knowledge-based programming
approach—and all the technology we’ve built—that one gets to the point where
simple code can routinely do really interesting and compelling things.

Translating out of Wolfram-ese:

"simple code doing interesting things" -> expressiveness

"knowledge-based programming" -> lots of libraries

"uniquely made possible by the Wolfram Language" -> we have the best
libraries, and therefore the most expressive language

Stephen Wolfram is a font of interesting ideas that deserve attention. He
really is an intelligent and perceptive guy. The problem is he's so arrogant
that he _consistently_ ignores (or, when he does acknowledge it, belittles)
what others have done. I find myself unable to trust anything he writes or
does because it's always filtered through the lens of his own brilliance - I
intuitively expect that such a person will ignore serious problems with their
own work because it's a threat to their ego.

I think we should look very carefully at his ideas, work out what they
_actually_ are (instead of what he thinks they are because he's not a reliable
source) and steal them.

------
entee
Every time I see something with Wolfram Language, I'm fairly impressed with
how powerful it seems.

But then I wonder, is that just because I see people who are skilled in the
art or is it intrinsic to the language? If it is so powerful, how come I don't
see more of it being used? Is this just because it runs on a closed system? So
does Matlab, but at least in my experience Matlab seems more widely used, why
is that?

~~~
pirate_parrot
You can't really compare MATLAB and Mathematica. Mathematica excels at
symbolic computation whereas MATLAB is primarily geared towards numerical
analysis and scientific computing. You could code numerical things in
Mathematica, but you'll get poor performance compared to MATLAB. Similarly,
MATLAB does have a symbolic toolbox, but it pales in comparison to the
extensiveness of Mathematica. Numerical and scientific computing work is
generally more useful in industry than anything you would do with symbolic
computation (e.g. you wouldn't analytically solve a sophisticated PDE so you
would use numerics), so that explains why MATLAB seems more prevalent. As for
your first question, I would say that Mathematica definitely has a lot of
power built in. I know a few researchers (myself included) who have used
Mathematica in some really cool ways only knowing the basics, which I think is
a huge audience for Wolfram. With that said, there are definitely many power
users who are probably doing greater things with the language.

~~~
taliesinb
> You could code numerical things in Mathematica, but you'll get poor
> performance compared to MATLAB.

Yes and no. MATLAB and Mathematica have access to the same BLAS libraries. If
you're using packed arrays in Mathematica, you can expect similar performance
for many pure numeric things. Mathematica is missing some of the higher level
primitives, there's no built-in function that corresponds to DGEMM, as a
random example.

Another weakness is that there's only a handful of packed array types, for a
64-bit system, you get tensors composed of doubles, signed 64-bit ints, and
complex numbers; no bool arrays, no unsigned 32-bit or 16-bit, no enum or
factor arrays. Now this is purely a performance thing -- you can make
tensors/arrays containing anything you want, but their contents just won't be
'packed' into a contiguous region of memory, instead they'll be arrays of
pointers to other memory on the heap. Such arrays are slower to work with,
much less memory efficient, harder to pass over an FFI, etc.

There's also a lack of fast workhorse-ish functions involving tensors, so
there isn't a way to broadcast a condition (say 4 <= x <= 10) onto an input
matrix to get a 'mask matrix' as is so common in MATLAB and R and so on, and
one of their secrets to writing fastish code in a interpreted language.

On the other hand, you can deal with ordinary lists (and Associations) that
contain arbitrary types (as with any dynamically typed language), which makes
many kinds of algorithmic work very straightforward. After all, not everything
is best represented as an n-tensor of reals or ints or bools! But if your
lists _do_ happen to be homogeneous lists of ints or reals (of any rank), they
will usually end up being stored more efficiently as mentioned above, a
process that is, for better or worse, totally invisible unless you know about
Developer/PackedArrayQ.

There is also Compile
([https://reference.wolfram.com/language/ref/Compile.html?q=Co...](https://reference.wolfram.com/language/ref/Compile.html?q=Compile))
which still has a fairly limited type system, but will still let you bypass
large amounts of interpreter overhead when you need to do something
performance critical.

> you wouldn't analytically solve a sophisticated PDE so you would use
> numerics

The whole analytic/numerical distinction really isn't true anymore (e.g.
[https://reference.wolfram.com/language/ref/NDSolve.html](https://reference.wolfram.com/language/ref/NDSolve.html),
[https://reference.wolfram.com/language/FEMDocumentation/tuto...](https://reference.wolfram.com/language/FEMDocumentation/tutorial/FiniteElementProgramming.html)).

> so that explains why MATLAB seems more prevalent.

I think the explanation lies more with MATLAB having exactly the right
features (or the right toolboxes) at the right time to fill niches in
thousands of engineering and research labs. If you're running a lab, and that
postdoc who wrote the code driving your instrument has long since left, there
is very little reason to embrace a new language, even if it has caught up in
various ways, and especially if that new language isn't tailored exactly to
what you are doing, and would prefer you to use some strange thing called
"functional programming", etc.

------
jtth
Up to FIVE FILES! OMG!

I love Mathematica and use it at least once a week. But these "free" versions
are nothing but your first hit. And the Wolfram Language is not something
you're going to figure out in the course of an afternoon with five notebooks.

------
FreedomToCreate
This is awesome, but man are they are ton of different programming languages
for the purpose of learning now. Most beginners are going to be confused on
just which one to pick.

Best to Wolfram. Lets see if this can become the pack leader.

------
jadbox
Two questions:

A) Can I run my programs locally without connecting to the cloud? B) Can I
dynamically embed generated graphs on my own site, instead of using the
Wolfram Cloud to host it?

~~~
strange_quark
A) Yes, if you buy Mathematica. B) Sure, but I think the user needs to install
a browser plugin.

~~~
carlob
B) not anymore

------
pdevr
Partially related: Wolfram Knowledge Base:
[https://www.wolfram.com/knowledgebase/](https://www.wolfram.com/knowledgebase/)

------
ralmidani
Massive egos aside, it's hard to think of a successful software company that
is more anti-freedom than Wolfram. While I think all software should respect
users' freedom, I recognize Apple, Microsoft, Oracle, and Adobe have all made
at least some meaningful contributions to free software.

~~~
gertef
This comment comes off as shrill, without an explanation of what "freedom"
means here, and why it is important.

Mathematica positions itself as a mathematical appliance, like a fridge or an
oven or a car, none of which are generally running free software.

~~~
wolfgke
> Mathematica positions itself as a mathematical appliance, like a fridge or
> an oven or a car, none of which are generally running free software.

And that is why there are Linux gurus that will invest lots of time to get
GNU/Linux run on their fridge - because there _are_ people who will not accept
this status quo.

