
Wolfram Programming Cloud  - Eduardo3rd
http://www.wolfram.com/programming-cloud/
======
mgraczyk
I just asked a few Wolfram employees at SXSW what this is. They said, "It's
Mathematica running on our servers with better data store and NLP
integration."

I also told them that the community seems confused about the product and that
this page seemed to be mostly marketing bullshit. For some reason that made
them really defensive, and they explained "It's pretty clear from the page
what we're offering and the people we're trying to reach will see the value."

FYI to those wondering.

~~~
taliesinb
Mathematica is a product that uses the Wolfram Language. As will be the
Programming Cloud.

"Mathematica in the cloud" would be Mathematica Online, a separate product
from the Programming Cloud:
[http://www.wolfram.com/mathematica/online/](http://www.wolfram.com/mathematica/online/)

See [http://www.wolframcloud.com/](http://www.wolframcloud.com/) for a wider
overview.

The Programming Cloud is specifically focused around workflows and features
that programmers are likely to want and need.

So I doubt any of us would have told you that the Programming Cloud is
"Mathematica running on our servers with better data store and NLP
integration." That's not the way we think or talk internally about our
technology stack, and its certainly not the way we talk to customers.

~~~
cormullion
Judging from the reactions in the press, and even in Mathematica user
communities, there's a lot of confusion about what's coming. For some people,
a bit of plain speaking, rather than marketing hyperbole and premature
teasing, would be welcome. However, I'll admit that the WolframBuzzWord
tactics are generating a lot of attention, which is probably the point.

------
joelgrus
I know those guys are super smart and all, but I can't read any of their
marketing materials without my bullshit detector going haywire.

~~~
bananas
Wolfram stuff is like a completely different world that doesn't acknowledge
anyone else. In context to them it makes sense, but to everyone else it's WTF
and meh and not much in between.

I remember the pre-Wolfram Alpha marketing. It wasn't nearly as impressive as
they made it out to be. The product was cool but to hype it up like that only
did damage.

To be honest it always reminds me of Futurama: "welcome to the world of
tomorrow!" (which is actually pretty shitty).

~~~
bane
The problem for them of course is that they exist in context to everything
else in the world. So a "huge" innovation to their local context, because they
just realized something everybody else knows, is just "meh" or "already tried"
and determined to be uninteresting or useless.

The problem for everybody else is that there's just enough interesting in
Wolfram's output to make it hard to dismiss outright.

~~~
taliesinb
> determined to be uninteresting or useless.

Your thesis seems to be that we're so naive that we re-invent discarded or
failed ideas and call them innovations. Can you give an example?

I'll give you just a two _counter-examples_ off the top of my head.

1\. Our frontend uses what _turned out to be_ functional reactive programming
to accomplish seamlessly interactive UI. And FRP is widely considered to be a
Good Idea.

2\. We invented the notebook-based REPL as the world knows it today, which is
of course copied by iPython (to such rave reviews). In fact, our language
embraces homoiconicity to such a degree that our notebooks are themselves
Wolfram Language expressions -- iPython is just JSON.

Seems like we're ahead of the curve in those two cases.

~~~
anaphor
Well the idea of building as much as possible into the language is old and has
repeatedly failed. Languages like PL/1, APL, and to a lesser extent PHP have
all tried and failed at this. People do not need huge languages with as much
stuff as possible crammed into them. What they need are languages where you
can be reasonably certain, and maybe even formally prove things about the
execution of your code (putting everything in The Cloud (tm) also hampers
this), and they need to be able to grow the language to fit their needs (e.g.
Scheme, Haskell, Clojure, etc... are all pretty good at this).

The whole idea of claiming "moar data" solves everything comes across as
incredibly naive and ignorant of what people like Tony Hoare, Dijkstra, or
Alan Perlis have said about computing.

There are two ways of constructing a software design: One way is to make it so
simple that there are obviously no deficiencies, and the other way is to make
it so complicated that there are no obvious deficiencies. The first method is
far more difficult -- Tony Hoare

~~~
taliesinb
> People do not need huge languages with as much stuff as possible crammed
> into them.

I think you should replace "people" with "systems programmers" in order not to
express an opinion that will in time (if not already) prove to be
anachronistic and narrow-minded.

And the kinds of things we're "cramming in" (in reality, very slowly and
methodically adding) have little to do with what you'd find in the languages
you mention.

Think of it like this: standard libraries are great, but give you access to
functionality that is effectively linear in the amount of stuff you learn,
because they cannot be too tightly coupled in order to remain modular in the
usual way.

With the Wolfram Language, you have more of a network effect: the more you
learn, the more useful what you already know becomes, because the topic
modelling you did _over there_ can produce a network you can cluster _over
here_ and that you can then decorate with the graphics primitives you just
learned about.

> The whole idea of claiming "moar data" solves everything comes across as
> incredibly naive and ignorant of what people like Tony Hoare, Dijkstra, or
> Alan Perlis have said about computing.

What is the "everything" that needs to be "solved"? Writing systems software?

I'm sure having graphs and images and timeseries built into your language
isn't tremendously useful for writing a server. But people have already
written servers. We don't need more languages to write servers (other than
Rust or Go, perhaps).

We "need" the next generation of smart apps, things you couldn't even
contemplate if you didn't already have access to curated data and algorithms
that all work together. Or rather, that's what Wolfram Research is trying to
make possible.

~~~
bananas
So in conclusion, it's not a systems programming language.

I think we got that.

So to break it down, and this is how I understand it as a user, it's a
collection of algorithms, Lego bricks of math and a library of data sources
glued together with a functional REPL that is semantically represented as a
notebook.

Can you stick that on the web site somewhere without the millions of bullet
points, marketoid spew and weaseling.

~~~
akater
Maybe system programmers are “doing it wrong” now?

Even when you write a simple VGA driver you have to solve some equations. They
are simple, so what does an average [good] C programmer does? He writes them
down in his favourite inexpressive specialized language. Consequences: 1) a
simple concept immediately becomes an incomprehensible mess; 2) approaches
using more advanced ideas rarely get the proper attention because a system
programmer is unable even to write them down, let alone reason about them and
tweak them. There is no reason why a VGA driver for certain microprocessor
could not be generated by a high-level language with the basic concepts behind
it expressed more clearly, and nevertheless formally.

~~~
bananas
Agree with you entirely (especially after recently writing an SSDP and UPnP
stack) but unfortunately the academics with all the supposed solutions have
managed to deliver nothing with any momentum, so we're stuck with a 40 year
old programming system and 30 year old abstractions.

Then again, you know what? It works pretty well so perhaps we're not doing it
wrong

------
rgbrgb
This may be worth it for the transition from lab project to app prototype but
I would be seriously wary of deploying anything significant on a proprietary
cloud in a proprietary language. Does anyone remember when Google App Engine
hiked their prices? A lot of people had to switch off the platform because the
traffic patterns of their apps did not work with the new pricing. That could
very easily happen here and you'd have to port to a different language, not
just a different runtime.

In my senior year of college we built some computer vision stuff in matlab
(pretty similar) that we ported to C++ to put in an iOS app. It would have
been cool to get a quick prototype by exposing some of the functions as web
services but there's no way I would release on the app store with that setup.

------
pshc
There's no way a proprietary environment can be the future of programming, but
Wolfram does have the right ideas.

Ctrl-F for "symbolic" in that page returns 14 results. The way I interpret it,
they're aiming (rightly) to dismount programming from its local maxima in
expressivity that is plaintext--a feat that Lisp and Smalltalk and a horde of
gimmicky visual languages* couldn't do. Wolfram Language won't succeed here,
but they'll get closer than anyone else has.

* Not saying that visual languages are inherently gimmicky; just that when you do write one, it's extremely tempting to fall into toyland.

~~~
seanmcdirmid
> The way I interpret it, they're aiming (rightly) to dismount programming
> from its local maxima in expressivity that is plaintext--a feat that Lisp
> and Smalltalk and a horde of gimmicky visual languages* couldn't do.

I'm sure they are referring to how the code is evaluated [1] vs. how it is
stored and manipulated by the programmer. Lisp and Prolog are the canonical
examples of symbolic languages, and they are both based on plain text.

[1]
[http://en.wikipedia.org/wiki/Symbolic_programming](http://en.wikipedia.org/wiki/Symbolic_programming)

~~~
taliesinb
That's right.

We can serialize any Wolfram Language expression as ASCII, if necessary (and
functions like Save do exactly that -- traversing the symbol graph to find all
definitions that a piece of code depends on) and dumping it out.

But you wouldn't want to do that in the case of packed arrays, timeseries, or
images -- the result would be incomprehensible (and incomprehensibly large).

Ultimately, Wolfram Language code consists of expression trees, these trees
are "conceptually" the equivalent of their FullForm
([http://reference.wolfram.com/language/ref/FullForm.html](http://reference.wolfram.com/language/ref/FullForm.html)).
What makes a WL expression "code" instead of "data" is that evaluating it will
change the state of the kernel so that it has new rules attached to various
symbols (functions + variables).

Plaintext files are just one vehicle for WL expressions. And in many cases
there are cool things you can do that require the code to live in an IDE that
can render WL expressions natively, such as

    
    
       Blur[<<picture of dog>>] 
    

or

    
    
       GeoLocation[<<NLP interpretation of "berlin">>]
    

For machines, the thing now known as the Wolfram Symbolic Protocol is used to
talk WL expressions over the wire. And there are two efficient binary
serialization formats: "MX" and "WDX".

------
primitivesuave
For API building this is a much needed paradigm shift to functional
programming. I met some backend engineers who built the backend of an very
large and complex system with OCaml, and they never wrote a single unit test
because they didn't really have to. Although humans are wired to think
procedurally, a pure functional style can eliminate many of the holes that are
easy to miss in a procedural program.

The only problem I see is that Mathemati... I mean, the Wolfram Language, is
not open source. This means that there could be some application-level bug in
the service running your API, and no community to quickly identify and patch
those bugs. Until things become more transparent, the handful of backend
engineers willing to write in a functional style will keep using OCaml or
Erlang.

~~~
taliesinb
> Until things become more transparent, the handful of backend engineers
> willing to write in a functional style will keep using OCaml or Erlang.

Hey Keshav!

I think it's a more complicated story than that. Our ambition is larger than
converting existing functional language programmers -- a lot of whom are happy
(and passionate) about their current tools.

I think it is a much wider stratum of smart people who want to do things that
were hitherto impossible (or impractical) without a vast amount of built-in
knowledge and algorithms. And their potential will be unlocked by the "curated
computing experience" that we provide.

Personally, I want everyone to be able to do the kinds of cool things that I
regularly do on weekend projects, and that I know cannot be achieved in
anything other than Wolfram Language.

And frankly, it'll be good for all of us to have an influx of new people with
new ideas from different backgrounds who want to build and compute new and
different kinds of things. Our tribe is still quite homogenous.

Although I suspect that at first it will be threatening to those of us who
derive our pride (and job security) from being masters of somewhat arcane
tools, processes, and knowledge.

~~~
anaphor
What do you say to people like Guy Steele who believe that small languages
that can be grown by their users are the way forward, and do not want to pay
to use a closed source programming language, ever?

(fyi I'm referring to this famous talk he gave
[http://youtu.be/_ahvzDzKdB0](http://youtu.be/_ahvzDzKdB0) )

~~~
taliesinb
Thanks for the talk, I'll watch it tomorrow (gotta catch Snowden's interview
at 10am).

But in the meantime, I'd say: pick your battles.

Many developers, including me, moved from Linux to OS X so they could get on
with their lives.

And we pay for things much lower on the abstraction hierarchy: CPUs and GPUs
and their proprietary IP, physical hardware, various industry-group protocols
and standards, OSes in some cases, hosting.

And we know from experience that the whole hierarchy tends to move down as we
build on it -- maybe the time has come for that to happen to languages, too.

If, in time, the things that WL is doing inspire higher-level, free languages
to raise the abstraction (and semantic) bar, I think we'll all benefit. For
now, we can only do what we do because we're a private company.

------
jdp
For some background on the language, check out Stephen Wolfram's intro video:
[http://www.youtube.com/watch?v=_P9HqHVPeik](http://www.youtube.com/watch?v=_P9HqHVPeik)

The demos are all pretty impressive, and putting aside the breathless
marketing of the programming cloud page, this looks awesome.

------
rlamby
As a long time Mathematica (MMA) user I can say I am confused and bemused as
to where Wolfram is heading. They have their fingers in so many pies its hard
to work out whats going on.

Recent Wolfram marketing on MMA/Wolfram language seem to be aimed at consumer,
Facebook and Hedgefund users rather than their traditional base in the
Sciences and Engineering.

There are plenty of pretty short examples, but the MMA kernel grinds to a halt
when pushing into larger problem sets. The CUDA and Parallel processor
commands are limited and haven't really been updated in the last few years
(pushing you back to other tools).

Developing on Workbench is anything but a joy and without even considering
speed one is better off developing on a regular programming IDE for programs
requiring multiple libraries. The notebook interface just doesn't handle large
programs well.

While functional programming is wonderful for some things, it is incredibly
hard to debug with the current tools and effectively provides a level of self
obfuscation when used exclusively.

The Computable Document Format (CDF) is a nice idea but the licensing terms
are too restrictive for any commercial work. At present CDF also has a pretty
slow, buggy interpreter.

All that said MMA is a great tool for early prototyping and a wide range of
analysis, you just need to consider switching to something else if you get
over several pages of code or utilize more than a few of your own libraries.

Like others have said, there are lots of tools out there and a combination of
them will still be needed to produce the best outcome after the release of
MMA10 and the Wolfram Cloud.

------
natch
Is this another one of those Wolfram projects where the results are returned
as images?

~~~
ethomson
I worked at Wolfram about twenty years ago, where I met a guy named Dan who
was (at the time) quietly hacking on a side project to put Mathematica on the
web. Eventually this project became "The Integrator" (and surprisingly, seems
to live on as integrals.com).

At first, The Integrator only returned results in mma syntax. If you entered
the expression `Cos[x]`, it would return - literally - `Sin[x]`. This was neat
and all, but once you had a result with exponentiation or division or what
not, you'd want a prettier result. For example, if you asked for the integral
of `Sin[x^2]`, it would spit out `Sqrt[Pi/2] _FresnelS[Sqrt[2 /Pi]_x]`, which,
you know, ew.

Twenty years ago, of course, there was no MathML - there wasn't even a working
group. So in order to provide a prettier result, he returned a GIF with the
Math-rendered output. Because this was back when we were still using client-
side imagemaps and some browsers still didn't support inline jpegs. So this
quick hack was totally reasonable.

Since The Integrator's compute backend was actually on his desk, he put a
caching layer in front of the Mathematica instance. It was a trivial one, so
if you asked for the integral of Sin[x], it would just look for Sin[x].gif in
the cache directory and if that existed, it wouldn't send the query of to the
Mathematica backend.

Unsurprisingly, this led to us kids just stuffing a bunch of crazy GIFs into
the cache directory. Dan started it - if you tried to integrate his initials,
it would return a picture of him. After that, though, we piled on and
eventually you could integrate all our names, as well as a bunch of internal
jokes.

I worked on The Integrator after Dan left, and of course I kept the easter
eggs, but at some point it was handed off to another team who tried to create
some more general web front-end to Mathematica. This team sadly lacked both
Dan's cleverness and his sense of humor, so not only was the software slow and
clunky, but it also lacked the easter eggs.

I'm always surprised that Wolfram Alpha - twenty years later - still renders
its results and returns a GIF. You'd think that we could do a little bit
better by now. I just hope that somewhere, one of the people working way too
many hours to keep that site online has slid some easter eggs in.

------
solipsism
For me the real achievement of Wolfram is the visualization capabilities. The
knowledge bases are nice if you happen to be interested in a domain that is
represented, and they make for great (controlled) demonstrations, but Wolfram
Alpha (which taps these same knowledge bases) really fails often when making
arbitrary but reasonable queries.

I think Wolframs visualization libs set a high bar, though, and I hope non-
closed communities (like the python scientific/mathematic programming
community, the R community, etc) will rally to meet the challenge.

~~~
vincetogo
My favourite Alpha goof is it interpreting the Planck mass as Max Planck's
weight.

~~~
taliesinb
That's fun, but seems to be fixed:

[http://www.wolframalpha.com/input/?i=+Planck+mass](http://www.wolframalpha.com/input/?i=+Planck+mass)

~~~
vincetogo
It shows up in more complex queries:
[http://www.wolframalpha.com/input/?i=+Planck+mass%2Ftau+mass](http://www.wolframalpha.com/input/?i=+Planck+mass%2Ftau+mass)

------
auvi
"THE WORLD'S HIGHEST LEVEL LANGUAGE" <\-- based on what?

~~~
bananas
Looks like mathematica in a web browser to me. Probably cheaper as well.

So it's not all that high level. It is compared to Fortran and floats
somewhere between R and Octave.

~~~
gwolfe3
IMO, the only reason you would say that is that you either know nothing about
Mathematica, or that your knowledge of it is very superficial (speaking as
someone who uses it daily).

~~~
bananas
I actually used it for about 3 years (2009-2012) for stochastic modelling
(insurance). We moved off the platform because to be honest we rewrote most of
the functionality we used in C# over a couple of weekends.

When I make those comments, they are about the language, not the ecosystem or
the product as a whole.

The language is merely _ok_.

The ecosystem, particularly with the amount of data feeds you can plug into it
is pretty good as is the sheer enormity of the library of off-the-shelf
functions it gives you.

~~~
gwolfe3
Ok, your comment was not about what I thought it was (if I understand your
response). It was really about how fast Mathematica is and not about the
symbolic functional / lisp like / whatever of the language?

~~~
bananas
It's more about what people use it for and how they use it rather than
capabilities. I was a little cranky and sarcastic initially and I don't think
that came across clearly!

------
darrellp
I think that Mathematica is innovative and love Mathematica. What I object to
is that pretty much everything I've seen in the ads is touted as
"revolutionary" when, in fact, it pretty much seems like a small upgrade to
Mathematica as we know it today. One of the breathless accolades I read touted
the "new" way you could type a one liner and have a video of an outline from
your cam. Very nice, but I went to my old version of Mathematica, typed in the
exact same thing with the exact same results. So while it's cool that
Mathematica/Wolfram Language can do this, at this point in time it's hard to
see where the new, circa 2014 revolution is coming about.

------
me2i81
Here's a writeup by David Auerbach on the Wolfram Programming Language:
[http://www.slate.com/articles/technology/bitwise/2014/03/ste...](http://www.slate.com/articles/technology/bitwise/2014/03/stephen_wolfram_s_new_programming_language_can_he_make_the_world_computable.single.html)

------
plg
It's hard to see this gaining traction in a world with the likes of iPython,
Octave, R, etc.

------
noname123
Cool, is Wolfram programming language basically Mathematica + some special
domain-area libraries?

~~~
gwolfe3
Here is my take about the difference between Mathematica and the Wolfram
Language: Mathematica is the combination of an interactive front end for
writing code/functions etc., sending them to the Mathematica Kernel, and the
displaying the results in the form specified by a functional wrapper you
specified. The Wolfram Language is what you use to talk to the Mathematica
kernel.

But you can also write and save WL code and submit it to the kernel directly.
It will do whatever it's supposed to do: acquire and process data, save the
results, and it includes all of the familiar Mathematica capabilities: image
processing, integrating functions, finding the solution for an equation. You
can do this in the kernel now.

The current development seems to be an extension of the range of the current
WL as used in Mathematica (the front end/kernel package) into a general
purpose language that includes all of the WL's current capabilities plus
various new ones that were missing. The WL preliminary documentation site
talks about the new stuff, but it's hard to know what's new if you aren't
familiar with the current version.

------
hafif
needs a tl;dr.

~~~
outside1234
for its tl;dr. I mean seriously, this page must have 50 bullets on it.

