
Wolfram Language - oneiric
http://blog.stephenwolfram.com/2015/03/frontiers-of-computational-thinking-a-sxsw-report/
======
one-more-minute
tl;dr: The Wolfram Language is an _ok_ 30-year-old language with a huge
standard library. You can do really amazing things in a single line of code...
as long as there's a built-in function to do that thing. Hmm.

I actually really like Mathematica as a tool for symbolic/mathematical stuff –
they're the best at what they do best. But all this Wolfram Language stuff is
just way overblown, and realistically a proprietary standard library – however
huge – just can't compete with the open source ecosystems of Python and
friends.

~~~
outworlder
> tl;dr: The Wolfram Language is an ok 30-year-old language I don't think it
> is just 'OK'. It is lispy, with a HEAVY emphasis on symbolic computation. I
> have yet to see anything even remotely similar to it. EDIT:

There's also the visualization aspect. Things like Jupyter (formerly iPython)
come close, but still can't do things like render video. If you don't want to
read the article, there's this video:
[https://youtu.be/_P9HqHVPeik?t=67](https://youtu.be/_P9HqHVPeik?t=67)
(initial ego trip skipped)

(Another edit: fix typo)

~~~
frik
The language agnostic Jupyter with its interactive notebook comes close to
Mathematica's environment. [http://jupyter.org/](http://jupyter.org/)

Jupyter supports Python and other languages like Julia
([https://github.com/JuliaLang/IJulia.jl](https://github.com/JuliaLang/IJulia.jl)
). I don't know if there are JS and Lua bindings but both would lend themself
because of their first class functions and functional language features.

~~~
stared
For JavaScript it is easy - just start a cell with "%%javascript", see e.g.
[http://nbviewer.ipython.org/github/davidrpugh/cookbook-
code/...](http://nbviewer.ipython.org/github/davidrpugh/cookbook-
code/blob/master/notebooks/chapter03_notebook/03_controls.ipynb)

------
sukilot
Whenever Wolfram writes/speaks, it's really hard to wade through Wolfram's
overlong rambling about how awesome he is, to find the interesting content.

~~~
F_J_H
Yes. I once read a quote that went something like: "I wonder which will become
self-aware first: Wolfram Alpha or Stephen Wolfram..."

~~~
TazeTSchnitzel
That reads better if you add a colon after "first", otherwise you might not
pause in the right place.

~~~
F_J_H
Agreed - that was a typo. I'd edit if I could.

~~~
dang
We added a colon for you.

(Compulsive editors ourselves, we welcome anyone being driven crazy by a
frozen typo or solecism in their comment to obtain relief by emailing
hn@ycombinator.com.)

~~~
F_J_H
Thanks!

------
GuiA
The Wolfram Language is quite cool. Sure, it's a shame it's proprietary - but
it has a lot to offer, a few neat ideas, and makes for great, visual demos
such as the ones featured in that talk. The fact that you can get cool things
running in a few lines of code, like the 3D stack of edges, is appealing - I
don't think there are many languages out there that allow you to do things
like this in a few lines of code, and with such flexibility.

(it is quite a shame that Wolfram always has to assert how great they are, how
revolutionary it is, how they invented everything, how unlike anything else
ever done before their work is. It's off putting. Let your work speak for
itself, and leave the meta comments out. But I digress.)

I like the "tweet a program" concept. One issue with kids growing up mostly on
mobile phones is that it makes them less likely to try to see what's inside
and program it themselves. One solution some have attempted is to have IDEs
directly running on tablets/phones, but those tend to be fairly clunky.
Allowing people to experiment with computation in unconventional manners, e.g.
over Twitter, strikes me as an interesting path. I had a similar project a
couple years ago where you would tweet concise instructions to a bot that ran
them into a virtual machine, for which the output was a 32x32 pixel image
buffer and would get tweeted back to you. If you've played with forth salon or
shadertoy, it's the same idea but with a language optimized so as to get cool
results in <140 characters. Sadly, like many of my other bots, Twitter shut it
down.

But yeah, given their aspirations for education etc., some open source
components would be nice. It strikes me as a great exploratory/prototyping
language, although it'd probably be hard to maintain large codebases of it due
to the fuzziness of the instructions and a certain opacity in the backend.

All that being said, the tail end of the talk (about immortality and the
singularity and the box of trillion souls - basically, when the paragraphs
don't have code examples anymore) does fall into the standard techno-religious
singularity crackpot speculation where things sound vaguely scientific - just
enough to give them an air of credibility - but where the terms used are fuzzy
and slippery enough to be manipulated into whatever direction the speaker
wishes while maintaining an illusion of rigorous reasoning.

~~~
Avshalom
I dunno, a lot of us got our start on TI calculators, and their input was
comparatively awful.

But they had a small environment and a hierarchial menu of the various key
words and common functions. And it worked pretty well.

~~~
GuiA
That's a good point! I also started programming on a graphing calculator.

One difference is that calculators were very limited in what they could do. No
camera, no GPS, no internet connection, the screen was monochrome and 80x80 or
so pixels... so the very limited language and input methods worked fine.

But on modern day devices, you want to build complex apps that can interact
over the network, use the various sensors on the device, display rich media,
manipulate video/images in real time, etc. The programming environment has to
allow for all of this, which is the tricky part.

------
jamii
Has anyone here used the Wolfram Language? How discoverable is it? How does
debugging work? What about state management? All the demos are small,
stateless calculations. What is it look like when you want to build long-
lived, stateful systems - say a robot that builds an internal map as it moves.

~~~
gh02t
It's OK. Debugging is doable, but it's a bit awkward IMO. In terms of
discoverability, well generally the documentation is among the best you will
find anywhere and it's all inter-linked and full of examples, so that's a
strong point. You can build programs with state, it mostly a functional
language but it doesn't enforce purity or anything.

It is certainly capable enough that building something like what you're
describing wouldn't be hard, but my experience is that it really isn't that
great for that kind of usage (part of this is the readability, more on that in
a sec). I think of it more as a "query" language... I tend to find that it
works best if you use it by building up a few fundamental entities (say,
symbolic equations or data) and then analyze them (transform data, plot, solve
equations etc). In this usage it's pretty amazing, but whenever I try to do
something like in a "real" programming language it is miserable. For instance,
I once implemented GMRES in it and jeez it was absolutely miserable. On the
other hand, I can do pure wizardry with stuff like data processing and
visualization.

Basically, as long as you stick to composition of built-in functions, it's
wonderful. When you want to do something from scratch though, that's when the
suffering starts. It's also really easy to shoot yourself in the foot
performance-wise... the language is very flexible in terms of allowing many
different programming styles. Typically, however, only the functional-style
implementation is really performant. For instance, you can use traditional
indexed loops just fine, but their performance is generally at least an order
of magnitude slower.

One other thing that drives me nuts about it is readability. It suffers from
the same issue as Lisps with parenthesis overload, except for WL it's all
braces and square brackets. If you put in good spacing and let the autoindent
do its thing then it is pretty readable, but a lot of people don't. Somebody
elsewhere linked this image
[http://indiegames.com/2014/03/10/wolfram%20example.jpg](http://indiegames.com/2014/03/10/wolfram%20example.jpg)
, which is a pretty good example of how it can be really awful. And writing
code that looks like that is pretty widespread in the community, though it has
gotten better in the past couple years.

Tl;dr I think it's pretty sweet, but I wouldn't use it for what you ask for.
Your tastes may differ, though.

------
Keyframe
From what was shown it is really cool. Not because of the language itself, but
for integration with data (from W|A?). It's like a CSI SQL.

Also, Wolfram is all nice for how he did this all by himself and how he let us
use big tower of ideas and technology he built, also by himself, over the past
40 years.

edit:

on a related note, how does it compare with IPython/Jupyter?

~~~
fl0wenol
It's not like the Wolfram Language examples you see are independent of the
Wolfram KnowledgeBase or their other cloud services, and you have to leverage
it from some deployed product (like Mathematica) you're paying for. This
detail is sort of glossed over.

You can do some of it from free-to-use services like Alpha.

Also, good god does he love to take credit. There's whole teams of people who
work on the underlying technology that powers it, although he does credit the
guys who come up with algorithms that they use, especially when documenting
them, but you have to dig for that... and then there's the people that gather,
purchase and curate data sets that power the Knowledge Base, and even the SMP
engine that became Mathematica was a group effort...

Which is why I'll never pay for a Wolfram Research product, as interesting as
or powerful as it could be. All it does it serve to support the legacy of an
egomaniac.

~~~
ForHackernews
It's super weird to me how Hackernews is extremely skeptical of Stephen
Wolfram's god-genius persona, while simultaneously being generally very
receptive to Elon Musk's similarly ginormous ego-tripping.

~~~
vijayr
Not sure about Elon Musk, but Apple comes across this way. They constantly
talk about how they "reinvented" everything, "re-imagined" everything, "went
back to the drawing board" etc while presenting new products. Kinda off-
putting. But to be fair these people/companies do amazing work, so I guess
some amount of ego is to be expected. Top athletes, musicians and pretty much
top people from most industries have huge egos. Comes with the territory, I
suppose.

~~~
Leszek
At least "reinvented" acknowledges that it was previously invented, Wolfram
tends to imply that his is the first system to do the things he describes.

------
calhoun137
Mathematica is very powerful, but it's also very expensive and based on a
proprietary code base. For me, this is unacceptable and the only solution in
my judgement is to build our own.

I have been working really hard on exactly that, and in the past 3 weeks have
made the most amazing progress. I don't want to spill the beans just yet, but
this is my second attempt at building a better mathematica, and this time
around I am using python, the scipy stack, and sage.

I will be releasing the project quite soon, as free open source software,
along with a website that is 100% free for everyone. I am really hopeful that
I will be able to find like minded programmers who are excited about working
on this project together.

If this sounds interesting to you, please reply in comments below, or else
reach out to me @calhoun137 on twitter.

------
erispoe
What's the business model of Wolfram? Do they make most of their reveue from
Mathematica or do other things like Wolfram Alpha and Wolfram Language bring a
significant chunk of it?

------
arturventura
I've been trying to implement a open source version of the Wolfram language
for FenixEdu but is extremely hard. For the most part is possible as long you
don't use stuff that depends of proprietary data sets. Also, after 30 years
working on it, it is quite faster than anything else.

I truly would like to see the community come up with a open source version of
it, but with such a huge size, the language would be near impossible for one
single individual to implement a compatible version.

~~~
mbrzusto
done! it's based on Macsyma
[http://en.wikipedia.org/wiki/Macsyma](http://en.wikipedia.org/wiki/Macsyma)
which is now Maxima
[http://en.wikipedia.org/wiki/Maxima_%28software%29](http://en.wikipedia.org/wiki/Maxima_%28software%29)

~~~
gohrt
Maxima seems very similar to Mathematica in principle. What does Mathematica
have in favor? Far more mathematician/engineer-hours invested due to early
(and then compounded) financial success?

------
rambulator
Mathematica is adequate for prototyping or detailed Science/Engineering etc
analysis provided datasets aren't large and the codebase is small.

Mathematica is very fast for your initial development, but you run into
massive bottlenecks when you jump from your small test cases to real world
data. In other words you get something up and running quickly, then spend a
massive amount of time manually (there is no proper debug environment)
debugging edge cases and trying to optimize it for real world cases. The time
savings aren't really there for many projects, as you end up spending more
time than if you had used something like C++.

The last version of Mathematica (v10) was released over a year ago without an
update to the Eclipse plugin, making an already pretty archaic development
experience impossible.

The front end debugger isn't a 'fair' debugger. When it works (which isn't
often) you are limiting to only running through small code snippets as its
impossible to trace anything.

There is no profiler.

The number of builtin functions is huge but many are effectively deprecated in
terms of their performance or existing bugs. Many of the functions like Map
(/@) aren't optimized. The irony is that once you have optimized your code it
ends up looking like that from any other language i.e. you have moved a lot of
Wolfram's high end functions.

I totally agree with others comments that code re-use is really difficult.
Many of Wolfram's comparisons compare code size with code complexity. Its not
always to the case, but 20 lines of Wolfram language can often be very
difficult to trace and understand.

Access to curated data is nice, but in many cases there is no information on
the accuracy or tolerances for data and it has been truncated (rounded to the
point of irrelevancy) or is missing elements. So like anything you still need
to verify it or access it directly from other sources. Things like units
cannot be used in functions/loops as it slows runtime to a crawl.

But horses for courses, the language is exciting for small projects and maybe
a jumping off point for people moving into full development of something.

One of the biggest issues facing Mathematica is simply that Wolfram Research's
focus is no longer Science and Engineering but rather the Internet of Things.

------
ENGNR
I'd like to use it commercially but it seems so expensive. $300 for only 3000
API calls.

I'd be happy to pay but it would need to be a marginal increment over the CPU
+ data costs. If that was the case they could get some serious volume and
momentum.

With only 3000 API calls any cool little prototype you made would hit the
limit within minutes of hitting the HN front page.

------
EGreg
At first I balked at a computer language being so "big" instead of being, say,
a functional language that can import yont of functions in a standard library.

But then I realized, this bridges the gap between computer languages and human
languages, which we all use to communicate. Although "keeping things
organized" in a regular computer language might be done more neatly in some
"computer oriented" way, when it comes to actually USING IT to EXPRESS
YOURSELF you'd need a professional to write he program for you.

Well, there still has to be clear, unambiguous documentation.

------
amelius
I wonder if a purely functional language would have been more appropriate,
given the fact that programs written in such languages are more amenable to
automatic rewriting and reasoning.

------
bigdubs
The "Language" seems like a big kit of built in functions with dubious
utility, with some awkward syntax thrown in to tie them all together.

~~~
ggchappell
> The "Language" seems like a big kit of built in functions with dubious
> utility, with some awkward syntax thrown in to tie them all together.

Having used it, I can assure you that, for people doing certain kinds of
analysis, those built-in functions are often of great utility.

(But think what you want about the syntax. :-)

------
Supersaiyan_IV
In case you don't know, there's "Tweet-a-program":

[https://twitter.com/wolframtap/](https://twitter.com/wolframtap/) some
incredible Wolfram examples live here.

------
Thiz
A cloud based open source organic language. That's it.

That's the greatest invention in the history of computing, and it is the final
step in cracking AI's nut.

Kudos Wolfram. You finally made it.

------
swehner
I expected something new in the area of natural language processing.

------
yarrel
It's proprietary.

Next.

~~~
TazeTSchnitzel
It may be proprietary, but it shouldn't be dismissed for it. It being
proprietary is a drawback, but it still brings great things to the table.

