taliesinb

But your argument implies that all video and audio and text content should be free. But it's not -- we pay content creators to create it, and if we didn't, a lot of that content wouldn't get created.

There will be "playgrounds" that demonstrate different features and domains for you to live-code in your browser, and those will be AFAIK signup free, but that feature isn't quite ready yet.

The Rasperberry PI contains a "free, period" release of the language: http://www.wolfram.com/raspberry-pi/

But no, the language is not open source, and that is unlikely to change in the future.

The new "fast introduction for programmers" is also a good place to start:

http://www.wolfram.com/language/fast-introduction-for-progra...

It was linked in the comments of this post, but the blog post of my colleague uses machine learning to predict the outcome of knockout matches with some 70% accuracy: http://blog.wolfram.com/2014/06/20/predicting-who-will-win-t...

I'm curious to know what you think makes Wolfram Language (which is the language used in the desktop program Mathematica) hopeless for large scale structured programming.

The last image isn't curve fitting -- it's showing the tradeoff of the true positive rate vs false positive rate as you vary the threshold of a binary classifier.

The "ML Studio" that briefly appears in the video looks like a slicker version of Weka.

Some of the WL code leaves a little to be desired. Here's a more idiomatic and readable Meal:

   Meal[forests_] := 
     Outer[Plus, forests, Permutations[{1, -1, -1}], 1] // Catenate // 
       DeleteDuplicates // Select[AllTrue[NonNegative]];

By the way, anyone who is new to the whole artificial life area should also take a look at Chris Adami's Avida: video [0], site [1]. Some Nature papers even came out of it, e.g. [2].

I'm going to shamelessly plug two abandonware projects of mine, being an agent-based neural network evolution sim [3] and a spatial game theory lab [4]. These might be interesting to people who like this kind of stuff.

But there's a huge amount of other stuff out there, e.g. projects like DarwinPond and prolific researchers like Martin Nowak [5].

[0] http://www.youtube.com/watch?v=ouF8wKxXWFQ

[1] http://avida-ed.msu.edu/

[2] http://adamilab.msu.edu/wp-content/uploads/Reprints/2003/Len...

[3] https://github.com/taliesinb/floatworld/wiki

[4] https://github.com/taliesinb/spatial-game-theory/wiki

[5] http://www.ped.fas.harvard.edu/publications/

Neat! I also liked some of the other Javascript demos on this site, like http://www.emergentmind.com/elementary-cellular-automata .

Heres's also a fun little video of vintage Dawkins showing off his program: http://www.youtube.com/watch?v=oDxaCJmlIGo

I have fond memories of programming variants of Dawkin's Biomorphs program in my early teens. I even sent him one of my creations, to which a grad student of his replied with kind encouragement!

One of the built-in models in the Wolfram Language does precisely this:

   In[1]:= Predict["NameAge", "Gertrude"]
   Out[1]= 84

   In[2]:= Quartiles @ Predict["NameAge", "Gertrude", "Distribution"]
   Out[2]= {62.8975, 74.7389, 84.8247}

More info about Predict and Classify here:

http://reference.wolfram.com/language/ref/Predict.html

http://reference.wolfram.com/language/ref/Classify.html

The venerable technology of print media has caused many such waves in the past.

The history of slavery provides many examples of how literature was kindling for huge changes in popular opinion that eventually ended slavery in the western world.

And literature is of course a mental bridge between people distant in time and space. More efficient bridges will be invented in the future, and they will become effective across species, too.

It's true that only autotrophs have the luxury of a guilt-free existence.

But if and when our deeper existential problems have been solved, we can imagine constructing robotic simulacra to give those predators satisfying prey to chase.

A deeper quandary might end up being: once we have done it for ourselves, are we obliged to cure death for other creatures, too?

One day we will use computers to bridge the human mental and social worlds with those of even quite alien creatures like the pacific octopus.

That will be the dawning of an age of widespread empathy with our animals brethren, along with a wave of horror and shame at our previous treatment of them.

Long before that, though, we'll enjoy immersive VR recordings from the viewpoint of other creatures. I wouldn't be surprised if Jim Cameron was involved in bringing such things to a wide audience.

But even with today's technology this recording from an eagle's PoV is a great example of how mesmerizing the alien worlds of our animal relatives can be: http://youtu.be/G3QrhdfLCO8

That's right, and what seems to be confusing people is that the language underlying Mathematica-the-product was always, implicitly, "Mathematica".

We were a one-product company, and it didn't make sense to distinguish Mathematica-the-product and the language it ran.

The last time we'd tried to branch the underlying language off into its own thing was in the early nineties, where a certain intern by the name of Brin was in the middle of refactoring the code before he went off to do other things :).

My prediction is that the confusion will pass soon once we have these concrete products actually out in the world.

A new generation of people will be using and seeing the language for the first time. And they'll be doing stuff that old-school Mathematica-the-product (and most of its user base) would find quite alien.

Things like trying code out in online sandboxes, coding things in the cloud IDE (or locally, via Eclipse or "Wolfram Desktop"), deploying public APIs for other people to use, building websites totally within the language, doing internet-of-things type stuff, embedding chunks of WL code in Java or Python or whatever, writing natural language parsers on top of Alpha's technology, creating data science workflows, making private clouds, designing interactive visualizations, tweeting code at our executor-bot... and on and on...

No.

Mathematica is a commercial piece of desktop software that uses the Wolfram Language. Just like how RStudio uses R.

There are other product platforms (coming soon) that employ the Wolfram Language, both in cloud and desktop incarnations: http://www.wolframcloud.com/

With debugging, we'll get there. I have some prototypes, but it's a long way from a research prototype to production, and we're still quite busy on getting actual products out the door.

And even at the moment, the fact that so much of a typical program in the Wolfram Language is referentially transparent means its easy to pick something up out of your codebase and mess around with it, then put it back. That's a huge win over procedural languages.

But in terms of the language, many of the ideas Chris is talking about are already possible (and common) in the Wolfram Language:

It's functional and symbolic, so programs are all about applying transformations to data. In fact, the entire language is 'data', with the interesting side effect that some 'data' evaluates and rewrites itself (e.g. If).

The mathematical sum notation is unsurprisingly straightforward in WL.

And StandardForm downvalues allow for arbitrary visual display of objects in the frontend.

For example, the card would have a symbolic representation like PlayingCard["Spade", 1], but you could write

  StandardForm[PlayCard[suit_, n_]] := ImageCompose[$cardImages[suit], $cardNumbers[n]];

to actually render the card whenever it shows up in the FrontEnd.

Graphics display as graphics, Datasets display as browseable hierarchical representations of their contents along with schema, etc...

Haha awesome. "Blur Blur" should work, I've filed a bug :-)

You will soon be able to use any of the cloud products mentioned on http://www.wolframcloud.com/.

There will also be Wolfram Desktop, the local IDE for the Wolfram Language that comes with our online products, as well as Mathematica 10, a non-cloud-enabled instantiation of the language for the academic market.

If you want notification as soon as we go public, sign up on http://www.wolfram.com/programming-cloud/.

Disclosure: I deployed this code from my own copy of a prerelease version of Wolfram Desktop, which I could do because I'm an employee.

P.S. Your idea of being able to write Wolfram Language code straight into Alpha and have it execute is an interesting one. You can do some basic stuff like http://www.wolframalpha.com/input/?i=Table[i^2%2C+{i%2C+1%2C...] already, but I agree we should allow you to execute anything (safe) using Alpha.

It sounds like you want to use the Wolfram Language rather than Wolfram Alpha.

Whenever it gets radically easier to do higher-level things, it usually takes a while for people to understand the possibilities.

We haven't released our cloud platform yet, but if there are particular domains you are interested in, you can poke around http://reference.wolfram.com/language/ to see what we have there. The examples to do with machine learning seems to be popular on http://www.wolfram.com/language/gallery/.

Well, it's Alpha, not the Wolfram Language.

But I don't think it takes much imagination to see how things like http://www.wolfram.com/language/gallery/visualize-celebrity-... or http://www.wolfram.com/language/gallery/plan-a-city-tour/ or http://www.wolfram.com/language/gallery/track-a-gps-equipped... or http://www.wolfram.com/language/gallery/email-freeze-alerts/ or http://www.wolfram.com/language/gallery/classify-images-as-d... could be the basis of something commercially valuable or publicly useful, especially given how easy they are to create. (edit: and those examples are not even designed for commercial appeal, just concision and cool factor).

Fill in anyone you want:

https://www.wolframcloud.com/objects/032f062e-5a63-4e3a-aff4...

Corresponding code:

  DogVision[img : (_Image | _Graphics | _Graphics3D)] := 
    Module[{rgbimg = ColorConvert[img, "RGB"], data}, 
     data = Transpose[ImageData[rgbimg], {3, 2, 1}];
     GaussianFilter[
      Image[Transpose[{(data[[1]] + data[[2]])/
          2, (data[[1]] + data[[2]])/2, data[[3]]}, {3, 2, 1}]], 5]];

  CloudDeploy[
   FormFunction[{"person" -> "Person"}, 
    DogVision[EntityValue[#person, "Image"]] &, "JPEG"], 
    Permissions -> "Public"]

The Edges of The Edge:

http://www.wolframalpha.com/share/clip?f=d41d8cd98f00b204e98...

Thanks!

A blow-me-down tutorial (or better yet, video with updating live REPL) is definitely on the cards.

> 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.

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.

That's fun, but seems to be fixed:

http://www.wolframalpha.com/input/?i=+Planck+mass

> 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.