taliesinb

Right, but fundamentally Lattice Boltzmann is just an optimization on top of lattice gas automata. It's continuum-ing up from a CA rather than discretizing down from Navier-Stokes.

And the Galilean invariance thing is kinda cool: who knew that you didn't need something as fundamental as Galilean invariance?

Yes, I think it is a lot like simulated annealing, with rounds of the following:

0. internal stresses exist = mutter "look at all these contradictions and warts"; start rethinking assumptions

1. raise temperature = get creative and start brainstorming; new possibilities and combinations present themselves

2. decrease in free energy = do a bunch of prototyping; some radical simplifications or changes of perspective present themselves

3. lower temperature = realize some details are still messy, some ideas were bad; get more conservative and start weeding out stuff

4. repeat until you have to ship

Hmhmhmhm... I'm working with the people who are building these cloud systems, so let me elaborate a little:

No, the Wolfram Language is not natural language. It's the LISP-like language behind Mathematica. We needed to do that from a branding perspective so that the Mathematica product can continue to exist for the academic market without being conflated with the underlying language, which has much wider aspirations.

But as for natural language, you can press '=' and go into 'natural language mode' and write stuff like "total the list", but in my opinion it isn't very good yet and is only really useful for absolute beginners. I think it could get much better in the future when we have nice sophisticated type inference going (which I am working on right now).

As for IPython: the In[..] and Out[..] lines you see in IPython (and amusingly some other cloud system-based IDEs now) mirror v1 of Mathematica back in 1987 (I believe deliberately). It's an amusing accident of syntax that evaluating In[1] works in both Python and Mathematica.

But yes, exactly, part of this whole story is an online IDE (actually, a set of them) that makes it extremely easy to get a whole system deployed. Imagine setting up some machine learning, creating some slick visualizations, allocating some persistent storage, putting it behind an API, and creating an embedded dashboard, all in the space of 20 minutes and a few dozens of lines of code.

The closest existing competitor is FP complete's cloud Haskell system, but I'd love to know about others.

I'm a Wolfram science summer school instructor, so I'm in a position to see the kinds of trends there are towards NKS-style methods. It's slow, but definitely there. Some of it is directly inspired, some of it is 'convergent evolution'.

Here's a very high-level and eclectic list of themes and specific research directions I can remember off-hand: agent-based modeling in economics and operational research, game theory automata in evolutionary biology, lattice gas methods in fluid dynamics, tessellation-based approaches to solving PDAs, L-systems in architectural design, logic automata for programming array-based computers, cellular automata-based PRNGs for stream ciphers, program search for finding lock-free concurrent algorithms, rBMs as used in deep learning.

In fact, I used an exhaustive NKS-style search the other day to find novel data query primitives (i.e. what other functions live in the type-signature space that MapReduce occupies?).

An entertaining read, but as an enthusiast of NKS-style science (and ohmygod bias! someone at Wolfram Research) I don't think the review is all that intellectually substantive: http://news.ycombinator.com/item?id=3974503

I meant the volume of comments, rather than submissions.

And I wasn't comparing to other programming subs, just saying comment threads don't get nearly as long as they ought to given how much activity is going on with Rust itself.

The meeting minutes are fascinating reading! The jostle of the decision making process is interesting, but I really relish the buffet of juicy technical details.

Pity that r/rust is still fairly low volume.

As a South African, I'm fascinated to learn that during the 1980s, PLATO was deploying for tertiary-school education, even in discriminated-against (e.g. black, 'coloured') colleges.

It's bizarre to think that in the dying days of apartheid there was already some faction of the government seduced by the promise of third-world techno-utopianism.

Is there any indication that the organisms we have "stolen" antibiotic molecules from might become themselves suffer disruption from bacteria that they can no longer kill? Fungi are involved in many symbiotic relationships that we indirectly depend on, for example the fixation of nitrogen for plant growth.

One imagines a future in which we have a dwindling supply of biodiversity to 'sacrifice' in order to keep ourselves safe from bacterial onslaught.

Not unlike oil -- millions of years to produce, but destroyed in a few generations of exponential human growth.

Hoare only gave this talk in 2009, whereas Go development started in 2007. Did Hoare express this opinion publicly (or privately, to the Go developers) before then? I can't easily find any indication that he did.

I can imagine goto makes region analysis hellishly more difficult, and region analysis is what gives Rust the ability to statically reason about reference lifetimes, which makes it practical to remove null references from the language.

So on the Rust view, goto is even more antithetical to safe code than on Dijkstra!

Unfortunately, by insisting that all data start in a zeroed state (as opposed to forbidding the use of uninitialized data, as Rust does), Go makes the same "Billion Dollar Mistake" that language designers have been making for decades:

http://www.infoq.com/presentations/Null-References-The-Billi...

Very cool. I'm hoping we can do similar things in the Wolfram Language.

Some of our stuff is simple database lookup (ala Google knowledge graph), other stuff is more algorithmic and computational in nature.

The problem we've had with SPARQL and co is that we feel it isn't optimized for computational queries. Ontologies don't matter as much in that case, and inference in tuple stores costs you significantly in performance, although the technology is improving.

As often as not, however, the computationally irreducible work lies in making a domain suitable for computational consumption, not in the technology used for representation.

To analogize, UTF-8 is great, but without the notion of Unicode code points it wouldn't exist.

IPython is catching up with the Mathematica frontend, slowly but surely. And that Julia demo is nice -- though I don't think a procedural language like MATLAB is the best model for a scientific language in this day and age.

We (Wolfram) are working on a web frontend for the Wolfram Language that will make the language "effectively" open, even if it is still proprietary.

And after the next version, we're going to be concentrating hard on defining a typed subset of the language that can compile via LLVM to all kinds of targets, including the browser.

For those who happen to have Mathematica, try this to get a smooth, high-resolution interactive fractal explorer (make sure you have a C compiler installed):

  JuliaFP = Compile[
    {{const,_Complex}, {init,_Complex}}, 
    Module[{val=init,n=0},
      While[Abs[val] < 5 && n < 25, val = val^2 + const; n++];
      {Mod[Arg[val]/(2*3.14159), 1], 1 - Abs[val]/5, 1 - Abs[val]/100}
    ],
    CompilationTarget -> "C", 
    RuntimeAttributes -> Listable, 
    RuntimeOptions -> "Speed"
  ];
  
  {fine, coarse} = Table[Complex[j,i], 
    {dx, {0.008, 0.002}}, {i,-1.5,1.5,dx}, {j,-1.5,1.5,dx}
  ];

  pt = {0.0,0.0};
  Graphics[{
    Raster[
      JuliaFP[Complex @@ pt/2, If[ControlActive[], fine, coarse]], 
      {{-2.0,-2.0}, {2.0,2.0}}, 
      ColorFunction-> Hue
    ],
    Locator[Dynamic[pt]]},
    ImageSize -> 800
  ] // Dynamic

P.S. Original post is awesome. I love the cow!

Mathematica is also an inherently interactive programming language, with images, graphs, vector graphics, and GUI elements being first-class values.

You can look at it that way. You can also see it as a modification of cylindrical LAB.

Explain your "slightly rotated" comment?

We use this trick in Mathematica, for what it's worth

Nice project. Do you know about HCL? http://hclcolor.com/.

There is also uniform perceptual LAB: http://www.brucelindbloom.com/index.html?UPLab.html which is a slight tweak to LAB to reduce the 'blue -> purple' effect that happens when you tweak chroma.

To supplement your point about L being the most important ordinate for distinguishing bordering colors: that is certainly true, but there are three other properties one wants for data visualization:

1. Once you've seen a colored element in the graphic, you want to quickly match it to its corresponding element in a legend (or vice versa). Having distinct hue and chroma is more important for this, because lightness is so vulnerable to your brain's tendency to 'correct' it based on contextual cues.

2. Hues should be aesthetically pleasing.

3. Lightness tends to impart connotations to an visualization: class X is more important than other classes if it is substantially darker or lighter. Same goes for chroma. So one wants to bound lightness and chroma to within a specific range when using them for class labeling.

Another deep complication is color impossibility, which is another way of saying that for any reasonably perceptually uniform color space like CIELAB, there is no straight-forward parametrization of the space that is both linear and avoids impossible colors.

My gut instinct is that space-filling curves could play a greater role in parameterizing the valid portions of such color spaces. Desiderata 3 is suggestive: we want some parameter that 'wiggles' within the allowed range of lightness and chroma to achieve both good distinction between nearby parameterized colors, and good global uniformity of color and chroma.

This wiggling could also 'absorb' the 'nooks and crannies' that color impossibility produces.

Still a research project, though.

Quick poll: is anyone here using RDF in their technology stack? What has your experience been like?

Thanks! Likewise, my eyes are always peeled for the latest stuff from MSR.

Yes. Fewer arrows has worked well for Apple.

We _are_ taking machine learning more seriously (I claim some credit here). My team is integrating ML into Mathematica 10 as we speak. And we've experimented with deep learning. I think some interesting things will come out of that in the future.

I think a hybrid approach is pragmatic. There is much computational knowledge that can't be assembled from web scrapes, as Google's purchase of Metaweb indicates (anyone remember Google Squared?).

Wasn't MSRA behind that amazing live English-to-Chinese translator [0]?

It's interesting to contrast Google's and Microsoft's approach with ours at Wolfram Research (at 0.3% their size, of course [1]).

We've come to see that it is very fruitful to live in a murky space somewhere between "commercial product" and "research project".

I'm thinking specifically about Wolfram|Alpha.

It's an enormous and daunting project. We've tackled a lot of very hard problems, and obviously have a long way still to go.

It has the weird property of being a thing that ships every week, but not one that the parent company depends on financially.

And so we kind of do our own thing, encoding domain knowledge, adding content, curating data, and designing frameworks, even if some if it won't ever make us any money (e.g. who will ever pay for dog vision [2]). We mostly just do things because they're cool or fun.

But it's been incredibly useful to drive innovation elsewhere in the company.

For example:

1. Alpha's unit system (the best in the world, the authors claim) is already in Mathematica 9.

2. Alpha is inspiring us to bring high-level semantic data and reasoning to Mathematica 10.

3. The automatic analysis in Pro is being souped up and will form part of Mathematica's predictive interface (automatic suggestions to "perform logistic regression", and so on).

4. We're working on taking the natural language understanding frameworks we've built for Alpha and using them to translate natural language queries into structured SQL or hierarchical document queries.

5. The domain specific languages we've invented to represent things in the real world are going to be exposed in a soon-to-be open format we're calling the Wolfram Data Format (which I hope will succeed where RDF is failing).

We wouldn't have though of any of this stuff without Alpha. And it wasn't explicitly driven by either commercial or basic research, but rather some kind of eccentric blend of the two.

[0] http://www.youtube.com/watch?v=Nu-nlQqFCKg [1] http://www.wolframalpha.com/input/?i=600+people+%2F+%28numbe... [2] http://www.wolframalpha.com/input/?i=apply+dog+vision+to+ima...

A rather spectacular example of MSR's work making it into a very successful consumer product is the pose estimator used by Kinect: http://videolectures.net/ecmlpkdd2011_bishop_embracing/

Perhaps their product R&D has slowed down a bit ("more wood behind fewer arrows"), but their academic research is still strong. Their collaborations with Hinton, Thrun, and Ng are just the most obvious and recent examples.

On the other hand, Microsoft has for a long time made a serious investment in basic research, both on the programming language side and on algorithms, but that hasn't stopped them from misfiring in multiple product categories.

What's the connection with Yandex?

Probably because Discourse is still risky, however cool it is: http://www.discourse.org/buy/

To celebrate, a Tau-shirt tutorial: http://community.wolfram.com/groups/-/m/t/63417

We're acutely aware of this. It's always a challenge to onboard users to a tool this broad and deep.

Refactoring our documentation a bit for M10 will help, the predictive interface in M9 helps, and there are some cool "code hint" ideas that are coming in M10 that will hopefully make it easier to keep learning.

We'll also soon be launching a community site to make it easy to discuss functionality, seek answers, and share code. For now, http://mathematica.stackexchange.com is a good resource.

We're also working on getting some materials about the Wolfram Language that should make it easier for people with existing programming experience to grok what is unique and different about WL, and how they might go about learning it.

Probably the best resource remains the existing Mathematica documentation. It is vast -- containing for example more than 100,000 evaluatable code snippets that demonstrate each function being used in multiple ways.

It is available online (http://reference.wolfram.com/mathematica/guide/Mathematica.h...) as well as in-product (double-click function you want to know about, then press F1 or Cmd+Shift+F). Following hyperlinks from familiar territory can get you a long way.

It's quite easy to get lost in it, of course, so here's a short list of "bread and butter" functions that I think every WL programmer should know really well: https://gist.github.com/taliesinb/5848321

Lastly, here is an eclectic mix of guides that might serve as good 'anchors' for some documentation spelunking:

http://reference.wolfram.com/mathematica/guide/LanguageOverv...

http://reference.wolfram.com/mathematica/guide/RulesAndPatte...

http://reference.wolfram.com/mathematica/guide/Patterns.html

http://reference.wolfram.com/mathematica/guide/StringPattern...

http://reference.wolfram.com/mathematica/tutorial/BlocksAndL...

http://reference.wolfram.com/mathematica/tutorial/LevelsInEx...

http://reference.wolfram.com/mathematica/tutorial/ApplyingFu...

http://reference.wolfram.com/mathematica/tutorial/Manipulati...

http://reference.wolfram.com/mathematica/tutorial/Introducti...

http://reference.wolfram.com/mathematica/guide/SymbolicGraph...

http://reference.wolfram.com/mathematica/Compile/tutorial/Ov...

http://reference.wolfram.com/mathematica/guide/GraphsAndNetw...

http://reference.wolfram.com/mathematica/guide/MatricesAndLi...