#WolfLang Blog

There are, I think, several reasons Hollywood movies often don’t get as much science input as they should.  The first is that movie-makers usually just aren’t sensitive to the “science texture” of their movies. They can tell if things are out of whack at a human level, but they typically can’t tell if something is scientifically off.  Sometimes they’ll get as far as calling a local university for help, but too often they’re sent to a hyper-specialized academic who’ll not-very-usefully tell them their whole story is wrong.  Of course, to be fair, science content usually doesn’t make or break movies. But I think having good science content—like, say, good set design—can help elevate a good movie to greatness.

As a company we’ve had a certain amount of experience working with Hollywood, for example writing all the math for six seasons of the television show Numb3rs.  I hadn’t personally been involved—though I have quite a few science friends who’ve helped with movies. There’s Jack Horner, who worked on Jurassic Park, and ended up (as he tells it) pretty much having all his paleontology theories in the movie, including ones that turned out to be wrong.  And then there’s Kip Thorne (famous for the recent triumph of detecting gravitational waves), who as a second career in his 80s was the original driving force behind Interstellar—and who made the original black-hole visual effects with Mathematica. From an earlier era there was Marvin Minsky who consulted on AI for 2001: A Space Odyssey, and Ed Fredkin who ended up as the model for the rather eccentric Dr. Falken in WarGames.  And recently there was Manjul Bhargava, who for a decade shepherded what became The Man Who Knew Infinity, eventually carefully “watching the math” in weeks of editing sessions.

All of these people had gotten involved with movies much earlier in their production.  But I figured that getting involved when the movie was about to start shooting at least had the advantage that one knew the movie was actually going to get made (and yes, there’s often a remarkably high noise-to-signal ratio about such things in Hollywood).   It also meant that my role was clear: all I could do was try to uptick and smooth out the science; it wasn’t even worth thinking about changing anything significant in the plot.

The inspiration for the movie had come from an interesting 1998 short story by Ted Chiang.  But it was a conceptually complicated story, riffing off a fairly technical idea in mathematical physics—and I wasn’t alone in wondering how anyone could possibly make a movie out of it.  Still, there it was, a 120-page script that basically did it, with some science from the original story, and quite a lot added, mostly still in a rather “lorem ipsum” state.  And so I went to work, making comments, suggesting fixes, and so on.

A Few Weeks Later…

Cut to a few weeks later.  My son Christopher and I arrive on the set of Arrival in Montreal.  The latest X-Men movie is filming at a huge facility next door.  Arrival is at a more modest facility.  We get there when they’re in the middle of filming a scene inside a helicopter.  We can’t see the actors, but we’re watching on the “video village” monitor, along with a couple of producers and other people.

The first line I hear is “I’ve prepared a list of questions [for the aliens], starting with some binary sequences…”.  And I’m like “Wow, I suggested saying that! This is great!”  But then there’s another take.  And a word changes.  And then there are more takes.  And, yes, the dialogue sounds smoother.  But the meaning isn’t right.  And I’m realizing: this is more difficult than I thought.  Lots of tradeoffs.  Lots of complexity.  (Happily, in the final movie, it ends up being a blend, with the right meaning, and sounding good.)

After a while there’s a break in filming.  We talk to Amy Adams, who plays a linguist assigned to communicate with the aliens.  She’s spent some time shadowing a local linguistics professor, and is keen to talk about the question of how much the language one uses determines how one thinks—which is a topic that as a computer-language designer I’ve long been interested in.  But what the producers really want is for me to talk to Jeremy Renner, who plays a physicist in the movie.  He’s feeling out of sorts right then—so off we go to look at the “science tent” set they’ve built and think about what visuals will work with it. 

Writing Code

The script made it clear that there were going to be lots of opportunities for interesting visuals.  But much as I might have found it fun, I just didn’t personally have the time to work on creating them. Fortunately, though, my son Christopher—who is a very fast and creative programmer—was interested in doing it.  We’d hoped to just be able to ship him off to the set for a week or two, but it was decided he was still too young, so he started off working remotely.

His basic strategy was simple: just ask “if we were doing this for real, what analysis and computations would we be doing?”.  We’ve got a list of alien landing sites; what’s the pattern?  We’ve got geometric data on the shape of the spacecraft; what’s its significance?  We’ve got alien “handwriting”; what does it mean?

The movie-makers were giving Christopher raw data, just like in real life, and he was trying to analyze it.  And he was turning each question that was asked into all sorts of Wolfram Language code and visualizations.

Christopher was well aware that code shown in movies often doesn’t make sense (a favorite, regardless of context, seems to be the source code for nmap.c in Linux).  But he wanted to create code that would make sense, and would actually do the analyses that would be going on in the movie.

In the final movie, the screen visuals are a mixture of ones Christopher created, ones derived from what he created, and ones that were put in separately.  Occasionally one can see code.  Like there’s a nice shot of rearranging alien “handwriting”, in which one sees a Wolfram Language notebook with rather elegant Wolfram Language code in it.  And, yes, those lines of code actually do the transformation that’s in the notebook.  It’s real stuff, with real computations being done.

A Theory of Interstellar Travel

When I first started looking at the script for the movie, I quickly realized that to make coherent suggestions I really needed to come up with a concrete theory for the science of what might be going on.   Unfortunately there wasn’t much time—and in the end I basically had just one evening to invent how interstellar space travel might work.  Here’s the beginning of what I wrote for the movie-makers about what I came up with that evening (to avoid spoilers I’m not showing more):

Obviously all these physics details weren’t directly needed in the movie.  But thinking them through was really useful in making consistent suggestions about the script.   And they led to all sorts of science-fictiony ideas for dialogue.  Here are a few of the ones that (probably for the better) didn’t make it into the final script.  “The whole ship goes through space like one giant quantum particle”.  “The aliens must directly manipulate the spacetime network at the Planck scale”.  “There’s spacetime turbulence around the skin of the ship”.   “It’s like the skin of the ship has an infinite number of types of atoms, not just the 115 elements we know” (that was going to be related to shining a monochromatic laser at the ship and seeing it come back looking like a rainbow).  It’s fun for an “actual scientist” like me to come up with stuff like this.  It’s kind of liberating.  Especially since every one of these science-fictiony pieces of dialog can lead one into a long, serious, physics discussion.

For the movie, I wanted to have a particular theory for interstellar travel.  And who knows, maybe one day in the distant future it’ll turn out to be correct.  But as of now, we certainly don’t know.  In fact, for all we know, there’s just some simple “hack” in existing physics that’ll immediately make interstellar travel possible.  For example, there’s even some work I did back in 1982 that implies that with standard quantum field theory one should, almost paradoxically, be able to continually extract “zero point energy” from the vacuum.  And over the years, this basic mechanism has become what’s probably the most quoted potential propulsion source for interstellar travel, even if I myself don’t actually believe in it. (I think it takes idealizations of materials much too far.)

Maybe (as has been popular recently) there’s a much more prosaic way to propel at least a tiny spacecraft, by pushing it at least to nearby stars with radiation pressure from a laser.  Or maybe there’s some way to do “black hole engineering” to set up appropriate distortions in spacetime, even in the standard Einsteinian theory of gravity.  It’s important to realize that even if (when?) we know the fundamental theory of physics, we still may not immediately be able to determine, for example, whether faster-than-light travel is possible in our universe.  Is there some way to set up some configuration of quantum fields and black holes and whatever so that things behave just so?  Computational irreducibility (related to undecidability, Gödel’s Theorem, the Halting Problem, etc.)  tells one that there’s no upper bound on just how elaborate and difficult-to-set-up the configuration might need to be.  And in the end one could use up all the computation that can be done in the history of the universe—and more—trying to invent the structure that’s needed, and never know for sure if it’s impossible.

What Are Physicists Like?

When we’re visiting the set, we eventually meet up with Jeremy Renner.  We find him sitting on the steps of his trailer smoking a cigarette, looking every bit the gritty action-adventurer that I realize I’ve seen him as in a bunch of movies.  I wonder about the most efficient way to communicate what physicists are like.  I figure I should just start talking about physics.  So I start explaining the physics theories that are relevant to the movie.  We’re talking about space and time and quantum mechanics and faster-than-light travel and so on.  I’m sprinkling in a few stories I heard from Richard Feynman about “doing physics in the field” on the Manhattan Project.  It’s an energetic discussion, and I’m wondering what mannerisms I’m displaying—that might or might not be typical of physicists.  (I can’t help remembering Oliver Sacks telling me how uncanny it was for him to see how many of his mannerisms Robin Williams had picked up for Awakenings after only a little exposure, so I’m wondering what Jeremy is going to pick up from me in these few hours.)

Jeremy is keen to understand how the science relates to the arc of the story for the movie, and what the aliens as well as humans must be feeling at different points.  I try to talk about what it’s like to figure stuff out in science.  Then I realize the best thing is to actually show it a bit, by doing some Wolfram Language live coding.  And it turns out that the way the script is written right then, Jeremy is actually supposed to be on camera using Wolfram Language himself (just like—I’m happy to say—so many real-life physicists do).

Christopher shows some of the code he’s written for the movie, and how the controls to make it dynamic work.  Then we start talking about how one sets about figuring out the code. We do some preliminaries.  Then we’re off and running, doing live coding.  And here’s the first example we make—based on the digits of pi that we’d been discussing in relation to SETI or Contact (the book version) or something:

What to Say to the Aliens

Arrival is partly about interstellar travel.  But it’s much more about how we’d communicate with the aliens once they’ve showed up here.  I’ve actually thought a lot about alien intelligence.  But mostly I’ve thought about it in a more difficult case than in Arrival—where there are no aliens or spaceships in evidence, and where the only thing we have is some thin stream of data, say from a radio transmission, and where it’s difficult even to know if what we’ve got should be considered evidence of “intelligence” at all (remember, for example, that it often seems that even the weather can be complex enough to seem like it “has a mind of its own”).

But in Arrival, the aliens are right here.  So then how should we start communicating with them?  We need something universal that doesn’t depend on the details of human language or human history.   Well, OK, if you’re right there with the aliens, there are physical objects to point to.  (Yes, that assumes the aliens have some notion of discrete objects, rather than just a continuum, but by the time they’ve got spaceships and so on, that seems like a decently safe bet.)  But what if you want to be more abstract?

Well, then there’s always mathematics.  But is mathematics actually universal?  Does anyone who builds spaceships necessarily have to know about prime numbers, or integrals, or Fourier series?  It’s certainly true that in our human development of technology, those are things we’ve needed to understand.  But are there other (and perhaps better) paths to technology?  I think so.

For me, the most general form of abstraction that seems relevant to the actual operation of our universe is what we get by looking at the computational universe of possible programs.  Mathematics as we’ve practiced it does show up there.  But so do an infinite diversity of other abstract collections of rules.  And what I realized a while back is that many of these are very relevant—and actually very good—for producing technology.

So, OK, if we look across the computational universe of possible programs, what might we pick out as reasonable universals to start an abstract discussion with aliens who’ve come to visit us?

Once one can point to discrete objects, one has the potential to start talking about numbers, first in unary, then perhaps in binary.   Here’s the beginning of a notebook I made about this for the movie.  The words and code are for human consumption; for the aliens there’d just be “flash cards” of the main graphics:

OK, so after basic numbers, and maybe some arithmetic, what’s next?   It’s interesting to realize that even what we’ve discussed so far doesn’t reflect the history of human mathematics: despite how fundamental they are (as well as their appearance in very old traditions like the I Ching) binary numbers only got popular quite recently—long after lots of much-harder-to-explain mathematical ideas.

So, OK, we don’t need to follow the history of human mathematics or science—or, for that matter, the order in which it’s taught to humans.   But we need to find things that can be understood very directly—without outside knowledge or words.  Things that for example we’d recognize if we just unearthed them without context in some archeological dig.  

Well, it so happens that there’s a class of computational systems that I’ve studied for decades that I think fit the bill remarkably well: cellular automata. They’re based on simple rules that are easy to display visually.  And they work by repeatedly applying these rules, and often generating complex patterns—that we now know can be used as the basis for all sorts of interesting technology.

From looking at cellular automata one can actually start to build up a whole world view, or, as I called the book I wrote about such things, A New Kind of Science.  But what if we want to communicate more traditional ideas in human science and mathematics?  What should we do then?

Maybe we could start by showing 2D geometrical figures.  Gauss suggested back around 1820 that one could carve a picture of the standard visual for the Pythagorean theorem out of the Siberian forest, for aliens to see.

It’s easy to get into trouble, though.  We might think of showing Platonic solids.  And, yes, 3D printouts should work.  But 2D perspective renderings depend in a lot of detail on our particular visual systems.  Networks are even worse: how are we to know that those lines joining nodes represent abstract connections?

One might think about logic: perhaps start showing the true theorems of logic.  But how would one present them?  Somehow one has to have a symbolic representation: textual, expression trees, or something.  From what we know now about computational knowledge, logic isn’t a particularly good global starting point for representing general concepts.  But in the 1950s this wasn’t clear, and there was a charming book (my copy of which wound up on the set of Arrival) that tried to build up a whole way to communicate with aliens using logic:

But what about things with numbers?  In Contact (the movie), prime numbers are key.  Well, despite their importance in the history of human mathematics, primes actually don’t figure much in today’s technology, and when they do (like in public-key cryptosystems) it usually seems somehow incidental that they’re what’s used.

In a radio signal, primes might at first seem like good “evidence for intelligence”.  But of course primes can be generated by programs—and actually by fairly simple ones, including for example cellular automata.  And so if one sees a sequence of primes, it’s not immediate evidence that there’s a whole elaborate civilization behind it; it might just come from a simple program that somehow “arose naturally”.

One can easily illustrate primes visually (not least as numbers of objects that can’t be arranged in non-trivial rectangles).  But going further with them seems to require concepts that can’t be represented so directly.

It’s awfully easy to fall into implicitly assuming a lot of human context.  Pioneer 10—the human artifact that’s gone further into interstellar space than any other (currently about 11 billion miles, which is about 0.05% of the distance to α Centauri)—provides one of my favorite examples.  There’s a plaque on that spacecraft that includes a representation of the wavelength of the 21-centimeter spectral line of hydrogen.  Now the most obvious way to represent that would probably just be a line 21 cm long.  But back in 1972 Carl Sagan and others decided to do something “more scientific”, and instead made a schematic diagram of the quantum mechanical process leading to the spectral line.  The problem is that this diagram relies on conventions from human textbooks—like using arrows to represent quantum spins—that really have nothing to do with the underlying concepts and are incredibly specific to the details of how science happened to develop for us humans.

But back to Arrival.  To ask a question like “what is your purpose on Earth?” one has to go a lot further than just talking about things like binary sequences or cellular automata.  It’s a very interesting problem, and one that’s strangely analogous to something that’s becoming very important right now in the world: communicating with AIs, and defining what goals or purposes they should have (notably “be nice to the humans”).

In a sense, AIs are a little like alien intelligences, right now, here on Earth.  The only intelligence we really understand so far is human intelligence.  But inevitably every example we see of it shares all the details of the human condition and of human history.  So what is intelligence like when it doesn’t share those details?

Well, one of the things that’s emerged from basic science I’ve done is that there isn’t really a bright line between the “intelligent” and the merely “computational”.  Things like cellular automata—or the weather—are doing things just as complex as our brains.  But even if in some sense they’re “thinking”, they’re not doing so in human-like ways.  They don’t share our context and our details.

But if we’re going to “communicate” about things like purpose, we’ve got to find some way to align things.  In the AI case, I’ve in fact been working on creating what I call a “symbolic discourse language” that’s a way of expressing concepts that are important to us humans, and communicating them to AIs.  There are short-term practical applications, like setting up smart contracts.  And there are long-term goals, like defining some analog of a “constitution” for how AIs should generally behave.

Well, in communicating with aliens, we’ve got to build up a common “universal” language that allows us to express concepts that are important to us.   That’s not going to be easy.  Human natural languages are based on the particulars of the human condition and the history of human civilization.  And my symbolic discourse language is really just trying to capture things that are important to humans—not what might be important to aliens.

Of course, in Arrival, we already know that the aliens share some things with us.  After all, like the monolith in 2001: A Space Odyssey, even from their shape we recognize the aliens’ spaceships as artifacts.  They don’t seem like weird meteorites or something; they seem like something that was made “on purpose”.

But what purpose?  Well, purpose is not really something that can be defined abstractly.  It’s really something that can be defined only relative to a whole historical and cultural framework.  So to ask aliens what their purpose is, we first have to have them understand the historical and cultural framework in which we operate.  

Somehow I wonder about the day when we’ll have developed our AIs to the point where we can start asking them what their purpose is.  At some level I think it’s going to be disappointing.  Because, as I’ve said, I don’t think there’s any meaningful abstract definition of purpose.  So there’s nothing “surprising” the AI will tell us.  What it considers its purpose will just be a reflection of its detailed history and context.  Which in the case of the AI—as its ultimate creators—we happen to have considerable control over.  

For aliens, of course, it’s a different story.  But that’s part of what Arrival is about.  

The Movie Process

I’ve spent a lot of my life doing big projects—and I’m always curious how big projects of any kind are organized. When I see a movie I’m one of those people who sits through to the end of the credits.  So it was pretty interesting for me to see the project of making a movie a little closer up in Arrival.

In terms of scale, making a movie like Arrival is a project of about the same size as releasing a major new version of the Wolfram Language.  And it’s clear there are some similarities—as well as lots of differences.  

Both involve all sorts of ideas and creativity.  Both involve pulling together lots of different kinds of skills.  Both have to have everything fit together to make a coherent product in the end.

In some ways I think movie-makers have it easier than us software developers.  After all, they just have to make one thing that people can watch.  In software—and particularly in language design—we have to make something that different people can use in an infinite diversity of different ways, including ones we can’t directly foresee.  Of course, in software you always get to make new versions that incrementally improve things; in movies you just get one shot.

And in terms of human resources, there are definitely ways software has it easier than a movie like Arrival.  Well-managed software development tends to have a somewhat steady rhythm, so one can have consistent work going on, with consistent teams, for years.  In making a movie like Arrival one’s usually bringing in a whole sequence of people—who might never even have met before—each for a very short time.  To me, it’s amazing this can work at all.  But I guess over the years many of the tasks in the movie industry have become standardized enough that someone can be there for a week or two and do something, then successfully hand it on to another person.

I’ve led a few dozen major software releases in my life.  And one might think that by now I’d have got to the point where doing a software release would just be a calm and straightforward process.  But it never is.  Perhaps it’s because we’re always trying to do majorly new and innovative things.  Or perhaps it’s just the nature of such projects.   But I’ve found that to get the project done to the quality level I want always requires a remarkable degree of personal intensity.  Yes, at least in the case of our company, there are always extremely talented people working on the project.  But somehow there are always things to do that nobody expected, and it takes a lot of energy, focus and pushing to get them all together.

At times, I’ve imagined that the process might be a little like making a movie.  And in fact in the early years of Mathematica, for example, we even used to have “software credits” that looked very much like movie credits—except that the categories of contributors were things that often had to be made up by me (“lead package developers”, “expression formatting”,  “lead font designer”, …).   But after a decade or so, recognizing the patchwork of contributions to different versions just became too complex, and so we had to give up on software credits. Still, for a while I thought we’d try having “wrap parties”, just like for movies.  But somehow when the scheduled party came around, there was always some critical software issue that had come up, and the key contributors couldn’t come to the party because they were off fixing it.

Software development—or at least language development—also has some structural similarities to movie making.  One starts from a script—an overall specification of what one wants the finished product to be like.  Then one actually tries to build it.  Then, inevitably, at the end when one looks at what one has, one realizes one has to change the specification.  In movies like Arrival, that’s post-production.  In software, it’s more an iteration of the development process.

It was interesting to me to see how the script and the suggestions I made for it propagated through the making of Arrival.  It reminded me quite a lot of how I, at least, do software design: everything kept on getting simpler.  I’d suggest some detailed way to fix a piece of dialogue.  “You shouldn’t say [the Amy Adams character] flunked calculus; she’s way too analytical for that.”  “You shouldn’t say the spacecraft came a million light years; that’s outside the galaxy; say a trillion miles instead.”  The changes would get made.  But then things would get simpler, and the core idea would get communicated in some more minimal way.  I didn’t see all the steps (though that would have been interesting).  But the results reminded me quite a lot of the process of software design I’ve done so many times—cut out any complexity one can, and make everything as clear and minimal as possible.

Can You Write a Whiteboard?

My contributions to Arrival were mostly concentrated around the time the movie was shooting early in the summer of 2015.  And for almost a year all I heard was that the movie was “in post-production”.   But then suddenly in May of this year I get an email: could I urgently write a bunch of relevant physics on a whiteboard for the movie?

There was a scene with Amy Adams in front of a whiteboard, and somehow what was written on the whiteboard when the scene was shot was basic high-school-level physics—not the kind of top-of-the-line physics one would expect from people like the Jeremy Renner character in the movie.

Somewhat amusingly, I don’t think I’ve ever written much on a whiteboard before.  I’ve used computers for essentially all my work and presentations for more than 30 years, and before that the prevailing technologies were blackboards and overhead projector transparencies.   Still, I duly got a whiteboard set up in my office, and got to work writing (in my now-very-rarely-used handwriting) some things I imagined a good physicist might think of if they were trying to understand an interstellar spacecraft that had just showed up.

Here’s what I came up with.  The big spaces on the whiteboard were there to make it easier to composite in Amy Adams (and particularly her hair) moving around in front of the whiteboard.  (In the end, the whiteboard got rewritten yet again for the final movie, so what’s here isn’t in detail what’s in the movie.)

In writing the whiteboard, I imagined it as a place where the Jeremy Renner character or his colleagues would record notable ideas about the spacecraft, and formulas related to them.  And after a little while, I ended up with quite a tale of physics fact and speculation.

Here’s a key:

(1) Maybe the spacecraft has its strange (here, poorly drawn) rattleback-like shape because it spins as it travels, generating gravitational waves in spacetime in the process.

(2) Maybe the shape of the spacecraft is somehow optimized for producing a maximal intensity of some pattern of gravitational radiation.

(3) This is Einstein’s original formula for the strength of gravitational radiation emitted by a changing mass distribution.  Qij is the quadrupole moment of the distribution, computed from the integral shown.

(4) There are higher-order terms, that depend on higher-order multipole moments, computed by these integrals of the spacecraft mass density ρ(Ω) weighted by spherical harmonics.

(5) The gravitational waves would lead to a perturbation in the structure of spacetime, represented by the 4-dimensional tensor hμν.

(6) Maybe the spacecraft somehow “swims” through spacetime, propelled by the effects of these gravitational waves.

(7) Maybe around the skin of the spacecraft, there’s “gravitational turbulence” in the structure of spacetime, with power-law correlations like the turbulence one sees around objects moving in fluids. (Or maybe the spacecraft just “boils spacetime” around it…)

(8) This is the Papapetrou equation for how a spin tensor evolves in General Relativity, as a function of proper time τ.

(9) The equation of geodesic motion describing how things move in (potentially curved) spacetime. Γ is the Christoffel symbol determined by the structure of spacetime.  And, yes, one can just go ahead and solve such equations using NDSolve in the Wolfram Language.

(10) Einstein’s equation for the gravitational field produced by a moving mass (the field determines the motion of the mass, which in turn reacts back to change the field).

(11)  A different idea is that the spacecraft might somehow have negative mass, or at least negative pressure.  A photon gas has pressure 1/3 ρ; the most common version of dark energy would have pressure −ρ.

(12) The equation for the energy–momentum tensor, that specifies the combination of mass, pressure and velocity that appears in relativistic computations for perfect fluids.

(13) Maybe the spacecraft represents a “bubble” in which the structure of spacetime is different.  (The arrow pointed to a schematic spacecraft shape pre-drawn on the whiteboard.)

(14) Is there anything special about the Christoffel symbols (“coefficients of the connection on the tangent fiber bundle”) for the shape of the spacecraft, as computed from its spatial metric tensor?

(15) A gravitational wave can be described as a perturbation in the metric of spacetime relative to flat background Minkowski space where Special Relativity operates.

(16) The equation for the propagation of a gravitational wave, taking into account the first few “nonlinear” effects of the wave on itself.

(17) The relativistic Boltzmann equation describing motion (“transport”) and collision in a gas of  Bose–Einstein particles like gravitons.

(18) A far-out idea: maybe there’s a way of making a “laser” using gravitons rather than photons, and maybe that’s how the spacecraft works.

(19) Lasers are a quantum phenomenon.  This is a Feynman diagram of self-interaction of gravitons in a cavity.  (Photons don’t have these kinds of direct “nonlinear” self interactions.)

(20) How might one make a mirror for gravitons?  Maybe one can make a metamaterial with a carefully constructed microscopic structure all the way down to the Planck scale.

(21) Lasers involve coherent states made from superpositions of infinite numbers of photons, as formed by infinitely nested creation operators applied to the quantum field theoretic vacuum.

(22) There’s a Feynman diagram for that: this is a Bethe–Salpeter-type self-consistent equation for a graviton bound state (which we don’t know exists) that might be relevant to a graviton laser.  

(23) Basic nonlinear interactions of gravitons in a perturbative approximation to quantum gravity.

(24) A possible correction term for the Einstein–Hilbert action of General Relativity from quantum effects.

Eek, I can see how these explanation might seem like they’re in an alien language themselves!  Still, they’re actually fairly tame compared to “full physics-speak”.  But let me explain a bit of the “physics story” on the whiteboard.

It starts from an obvious feature of the spacecraft: its rather unusual, asymmetrical shape.  It looks a bit like one of those rattleback tops that one can start spinning one way, but then it changes direction.  So I thought: maybe the spacecraft spins around.  Well, any massive (non-spherical) object spinning around will produce gravitational waves.  Usually they’re absurdly too weak to detect, but if the object is sufficiently massive or spins sufficiently rapidly, they can be substantial.  And indeed, late last year, after a 30-year odyssey, gravitational waves from two black holes spinning around and merging were detected—and they were sufficiently intense to detect from a third of the way across the universe.  (Accelerating masses effectively generate gravitational waves like accelerating electric charges generate electromagnetic waves.)

OK, so let’s imagine the spacecraft somehow spins rapidly enough to generate lots of gravitational waves.  And what if we could somehow confine those gravitational waves in a small region, maybe even by using the motion the spacecraft itself?  Well, then the waves would interfere with themselves.  But what if the waves got coherently amplified, like in a laser?  Well, then the waves would get stronger, and they’d inevitably start having a big effect on the motion of the spacecraft—like perhaps pushing it through spacetime.

But why should the gravitational waves get amplified?  In an ordinary laser that uses photons (“particles of light”), one basically needs to continually make new photons by pumping energy into a material.  Photons are so-called Bose–Einstein particles (“bosons”) which means that they tend to all “do the same thing”—which is why the light in a laser comes out as a coherent wave.  (Electrons are fermions, which means that they try never to do the same thing, leading to the Exclusion Principle that’s crucial in making matter stable, etc.)

Just as light waves can be thought of as made up of photons, so gravitational waves can most likely be thought of as made up of gravitons (though, to be fair, we don’t yet have any fully consistent theory of gravitons).  Photons don’t interact directly with each other—basically because photons interact with things like electrons that have electric charge, but photons themselves don’t have electric charge.  Gravitons, on the other hand, do interact directly with each other—basically because they interact with things that have any kind of energy, and they themselves can have energy.  

These kinds of nonlinear interactions can have wild effects.  For example, gluons in QCD have nonlinear interactions that have the effect of keeping them permanently confined inside the particles like protons that they keep “glued” together.  It’s not at all clear what nonlinear interactions of gravitons might do.  The idea here is that perhaps they’d lead to some kind of self-sustaining “graviton laser”.

The formulas at the top of the whiteboard are basically about the generation and effects of gravitational waves.  The ones at the bottom are mostly about gravitons and their interactions.  The formulas at the top are basically all associated with Einstein’s General Theory of Relativity (which for 100 years has been the theory of gravity used in physics).  The formulas at the bottom give a mixture of classical and quantum approaches to gravitons and their interactions.  The diagrams are so-called Feynman diagrams, in which wavy lines schematically represent gravitons propagating through spacetime.

I have no real idea if a “graviton laser” is possible, or how it would work.  But in an ordinary photon laser, the photons always effectively bounce around inside some kind of cavity whose walls act as mirrors.   Unfortunately, however, we don’t know how to make a graviton mirror—just like we don’t know any way of making something that will shield a gravitational field (well, dark matter sort of would, if it actually exists).  For the whiteboard, I made the speculation that perhaps there’s some weird way of making a “metamaterial” down at the Planck scale of 10-34 meters (where quantum effects in gravity basically have to become important) that could act as a graviton mirror.  (Another possibility is that a graviton laser could work more like a free-electron laser without a cavity as such.)

Now, remember, my idea with the whiteboard was to write what I thought a typical good physicist, say plucked from a government lab, might think about if confronted with the situation in the movie.  It’s more “conventional” than the theory I personally came up with for how to make an interstellar spacecraft.  But that’s because my theory depends on a bunch of my own ideas about how fundamental physics works, that aren’t yet mainstream in the physics community.

What’s the correct theory of interstellar travel?  Needless to say, I don’t know.  I’d be amazed if either the main theory I invented for the movie or the theory on the whiteboard were correct as they stand.  But who knows?  And of course it’d be extremely helpful if some aliens showed up in interstellar spaceships to even show us that interstellar travel is possible…

What Is Your Purpose on Earth?

If aliens show up on Earth, one of the obvious big questions is: why are you here?  What is your purpose?  It’s something the characters in Arrival talk about a lot.  And when Christopher and I were visiting the set we were asked to make a list of possible answers, that could be put on a whiteboard or a clipboard.  Here’s what we came up with:

As I mentioned before, the whole notion of purpose is something that’s very tied into cultural and other context.  And it’s interesting to think about what purposes one would have put on this list at different times in human history.   It’s also interesting to imagine what purposes humans—or AIs—might give for doing things in the future.   Perhaps I’m too pessimistic but I rather expect that for future humans, AIs, and aliens, the answer will very often be something out there in the computational universe of possibilities—that we today aren’t even close to having words or concepts for.

And Now It’s a Movie…

Arrival is officially released tomorrow.  The movie came together really well, the early responses look great… and it’s fun to see things like this (yes, that’s Christopher’s code):

It’s been interesting and stimulating to be involved with Arrival.  It’s let me understand a little more about just what’s involved in creating all those movies I see—and what it takes to merge science with compelling fiction.  It’s also led me to ask some science questions beyond any I’ve asked before—but that relate to all sorts of things I’m interested in.

huh? Oh I see it blurs images to different degrees. Um think again and check below the picture

Yup, looking below the cat we see that MeanFilter also does some number stuff. So what in the world does it actually do?! I dunno.

4. FindClique - Yup even Wolfram Language wants to be one of the popular ones. This function locates the cliques in a set of connected data. Check out this epic example: Find the terrorist cells in the 1998 East Africa embassy attack network

5. OrnsteinUhlenbeckProcess - I mean everyone knows the Ornstein Uhlenbeck Process so I really don’t need to bring it up, but check out that sweet result: mu!

6. Beep - Well I don’t exactly have an audio recording to share, but yup does exactly what it says it does: beeeeeeeeeeep.

7. BubbleChart - BubbleCharts are truly essential. I insist on seeing graphs where it looks like someone upchucked all over it. Lot of stuff down in the 0.7 range if you ask me.

8. $MaxMachineNumber - How high can your operating system count? Yeah, wow. Let’s see if you can count that high.

9. SolarEclipse - Actually this one is kinda useful. Gotta remember to wear my sunglasses - er, bring a flashlight.

10. ButterworthFilterModel - Seeming so simple and innocent, so lovely and buttery, putting but the third lowest whole number known to man yield an absurd result crazy enough to scare off any but the most ingenious of mathematicians 

11. Riffle - Riffffffle! Great name, great function. Riffles any data set with the parameter of your choice. Riffle with Ruffles if you must.

12. FindPostmanTour: UPS! If you’re reading this you’ve found your solution to all your problems. The description for this one is: “finds a Chinese postman tour in the graph g of minimal length.”

13. TreePlot - If you’ve ever taken a computer science algorithms class, this function is actually great for visualization. Otherwise - “oooo pretty lines!”

14. InexactNumberQ - No explanation needed.

15. FromDigits - Help, I’ve accidentally put commas in between numbers I need together!.... Phew there is a solution!

Okay, being mean again. This function can be really cool when dealing in base X numbers.

16. Antialiasing - From the description “Antialiasing fuzzes out edges of graphical elements so as to avoid the appearance of jaggedness associated with discrete screen pixels. With Antialiasing->True, black lines may appear slightly gray. “ ... Black to Slightly Gray??!?!?!?! Noooooooooo.

18. SatelliteData - Where are those things flying!

19. GeoVisibleRegionBoundary - Even cooler, taking the above data, what region of the world can a satellite see at a given time? Don’t do anything bad when they’re watching!

20. Pruning - Ever wanted to trim the fat? Pruning takes an image and fills it with certain ranges of black pixels to make the image just show the important stuff. It reduces branches, and therefore “prunes” them. However my infinite pruning of this cool pyramid thing didn’t do much other than take away the line on the right. Oh well.

21. ChineseRemainder - Let me know if you figure out how in the world this all is calculated- beats me.

Well that’s all for now folks. Hope you were a bit amused but also a bit secretly impressed at the fast functionality of Wolfram Language.

I’m a one man Wolframpack, so please Find me a Clique,

All the best,

statement. No print statement?!?! Yes, dear reader. Throw out all conventional "Hello World!" syntax you know because the above two lines spits out a name and an image.

Okay so in reality, the final product is a few more than two lines, but the core functionality is essentially two. And that is sweet.

If you go to Celebritymatch.io, you see that can you upload a picture on The Landing Page and image is sent to and processed by The Core Functionality, which is finally sent back via a Connecting API to display you next to your celebrity twin. To really give a good explanation, one worthwhile that can help you learn a lot about the Wolfram Langauge, lets break down each part (The Landing Page, The Core Functionality and the Connecting API) into pieces we’ll call the good, the bad, and the ugly. Let’s also describe how you might something similar.

1. The Landing Page:

Resources To Follow along:

-Celebmatch.io

-Celebrity Match Page Source

a. The Good

The landing page of Celebritymatch.io is pretty simple. Created with HTML, CSS and Javascript it pulls from a variety of pre-existing stuff to make it work. Like any lazy bum (me) I used Bootstrap to make it look smooth, good on other browsers and good on mobile. Ain't nobody got time to test Firefox, Internet Explorer and what's that default browser that you can never switch to Chrome fast enough for... Safary? Yeah I think that's how you spell it.

Couple of neat things web dev stuff I learned about in completion of this page. First, for those new to HTML like me, the <noscript> tag is used in case the browser is ancient and doesn't support JavaScript.

Second, when you're using Bootstrap, really pay attention to making sure that any new tag you add (div, section, etc.) has an id equal to a known class. Just putting in an <img> will look pretty bad if not bootsrap-ified. And third, use <meta> tags in the header to tell the browser how to share and display your site with the world.

To share for our site I used AddThis, a widget that gives you beautiful share buttons for your site content. Their free ones are better than the paid ones in my opinion. Words for the wise though: I haven't done much network traffic analysis on what putting AdThis does to your website, but while this is a free and easy option, I think that AddThis will be monitoring your website visitors' behavior and using the information for ad targeting. Everyone and their digital marketing uncle is doing web tracking these days, but since your users might not like it, it is something to consider.

The background image on the website is one of my favorite parts. Want to know a secret? That image was made in the Wolfram Language. Using one little command:

Then add in a bit of purple color fading (go read the dang documentation to learn how, I'm not going to spell it out for you!) and the Export[] function, and we had a beautiful banner image jpg that is the background of the site.

The drag'n'drop site option was also a breeze using the javascript from www.dropzonejs.com. Using the div id, "date-entry," it was simple to place it on top of the background and redirect the file to be processed by Wolfram Language (sent through by a quick'n'dirty API we made that I'll explain later).

b. The Bad

Okay so what went wrong in our first few site iterations that we changed? A lot. For starters we had a lot more clutter on the page, a few more images, including this one for the title:

Simpler is always better.

Before we switched to drag and drop and Wolfram Language APIs, I had the site on i-look-like.herokuapp.com (check out that little mess!). Without going into Wolfram Language jargon, I deployed the core functionality of the site to a wolfram based url like this one:

https://www.wolframcloud.com/objects/user-874811a9-16a9-484c-9346-4513ac69bd23/i-look-like

Super easy to get out there if you’re crunched for time (one function!) and definitely the quickest option if you don't want to make your own website (though you can use an HTML template I made for those interested! See the blog post on "0 to Product Launch in 2.7 seconds"). All you have to do is wrap your product in the function CloudDeploy[] and you get a custom URL. Even better, like what we did, wrap all of that in the function EmbedCode[] which gives you an HTML iframe that you can include on your website, like I did on the i-look-like.herokuapp.com site. The embedded iframe has a drawback though - you have to make the iframe big enough to encompass your largest output, but if you're viewing the site on mobile or on a smaller window, you'll cut off the output. It's also impossible to share your output, something that was really important to us.

If you want to get a laugh at my first attempt to make an iframe with Wolfram Language work properly, check out bit.ly/PoisonousOrNotWolfram - I made an app in Wolfram Language that allows you to take a picture of a plant and it will tell you if that plant is poisonous or not. P.s. it's only like 70% accurate so please don't bet your life on what I made at a hackathon in 12 hours.

c. The Ugly

Something that I spent a lot of time working on but never got right, was the Celebritymatch.io share option to Facebook. I had two main problems.

First was that I couldn't get the Facebook share display picture to show the Celebritymatch.io output. 

When you see shared Facebook links you usually see a nice image accompanying the share. Common psychology tells us that you're more compelled to click the link if the picture piques your interest. So rather than share Wolfram's Logo, I'd really like to be able to share the picture of your and your celebrity look alike. However, since I don't know what that output will be until after you enter in your picture, I'll need to programmatically change the share tag. The share tag for Facebook looks like this:

<meta property="og:image" content="http://media.wolfram.com/logos/images/wolfram-language-logo.png" />

The content I have here is the normal Wolfram logo. And so after you receive you result, my plan was to replace the content with the correct imgsrc with a line like:

$('meta[property=og\\:image]').attr('content', imgsrc);

that executes when the document loads. Yes it changes the content tag, but Facebook shares using the page source, not the dynamically changed element. So alas - had to stick with my boy Wolfy, the Wolfram mascot. If you know how to do this - let me know!

The second problem I had was that when you click on the shared URL, the image of you and the celebrity needs to reload from the Wolfram server where it is stored, instead of stored statically on the page. Otherwise it would load significantly faster. I'm still looking into this problem.

2. The WL code

Resources: Celebritymatch.io Core Functionality

a. The Good

The core code that is implemented in Wolfram Language is absolutely what drives Celebritymatch.io . We used a few dozen of Wolfram's built in functions, which saved us, in turn, tens of thousands of lines of code.

The core of the core code was, as written above, just two lines. But we augmented those lines to get the really great output you see now on the website. I worked with a fellow intern Mark Peterson on the Wolfram Language code and he took me from B- to A+. His suggestions were awesome and improved the site as we built on each other's code. Wolfram Language is really useful for code sharing because, not only can you share and collaborate on a single notebook document (the file type for Wolfram Language is Notebook, or ".nb") simultaneously, but to augment each other's code, we just had to wrap more functions around the core code to make it better and prettier.

Let me start by breaking down the final product, and then we'll get from that two-liner to the magic. Any words that I Capitalize will indicate that it is a Wolfram Language function that was used.

The final product output is a JPG Image. This Image is a combination of three smaller Images arranged in a Row. In the left Image, we see a picture of the celebrity that you look like. The Image is cropped (ImageCrop, the edges are Blur-red, and then ImageSize-d to match a set of height and width parameters that I provided (approx 1000x400 pixels). The middle Image is a Graphic composed of a Styled Table, with a Colored Arrow that had as BSplineCurve and Blend-s into the White background on the top and bottom of the Table, and a Styled Text sentence in the Center of the Table that says "Wow, You look just like celebX" where celebX is the CommonName of the NotablePerson that you look like.

Okay so a bit more complicated than two lines, but nothing you couldn't imagine up yourself. If you notice, most of the functions we used were about the display output, which all things considered, as long as you have the core working, you can wait until later to make the output pretty.

So how did we make the Image look pretty? A lot of trail and error! I'm proud of the final product though so let's break it down. We realized that we'd be dealing with pictures where the person in question could be anywhere in the photo, as could the celebrity in theirs. To make the visitor really see the similarities in the two people, we needed to show the celeb's face as close as possible to the visitor's face.

What truly mattered in any case was the face. So we turned to Wolfram for an awesome function: FindFaces. FindFaces, identifies all the faces in a photo. You can look at the documentation for specifics but we had our function grab the most important face in the photo in case someone uploaded a photo with multiple people. Once we identified the face, we were able to get the dimensions in pixels for the face and resize the photo such that the face was centered, larger, and matched the face size of the celebrity. We used functions like ImageCrop, ImagePad, ImageResize and ImageDimensions - easy peasy! Then we just applied a good Blur around the edges of the image voila (help, where do I put the accent on that silly word?).

Once we had our people images, we smushed the middle one in their with the text and arrows (the arrows were a bit math-y but used functions like Arrow, ArrowHeads BSplineCurve, RGBColor, Thickness, and Style). Our overall Image was a Row of Images (celeb, arrow/text, you). We added some attributes on it to make it look nice check 'em out:

Background -> White,

RoundingRadius -> 10,

ImageMargins -> 10,

Frame -> True,

ImageSize -> {width + 30, height + 30}

And I'm sure you can figure out what all of those attributes means.

Finally, we put all of this code wrapped in a function that we named "formatResult" whose first few lines looked like this:

b. The Bad

If you look at each of our six versions of the Celebritymatch.io core function, each time we make it look a little better and knock out a few corner cases. Commenting and leaving headers were key in the process, and a great feature of Wolfram Language.

Some of the corner cases were interesting. It turns out that while Wolfram has a vast database of people on file (PersonData), it doesn't have every possible "field" for every celebrity. Sometimes it might have a celebrity, but not have the photo to go with it. In this case we decided to be sly and make a displayed graphic that said "celebX is too embarrassed to be seen next to celebGenderPronoun better version. Try another picture and maybe you'll get a more sporting match" where celebX is the name of the celebrity and celebGenderPronoun was the pronoun associated with the celebrity's gender found by the line of code

CommonName[PersonData[celeb,"Gender"]]/.{"male"->"his","female"->"her"}

The "/." means depending on the earlier result, replace it with the value of the key that is the result. In other words if the celebrity is a male, put "his" and if a female, put "her." Good stuff.

We also ran into the issue of a person uploading a stupid photo of something like a lamp or a waterfall. In this case, our code wouldn't be able to identify a face in the photo to focus on (remember we used FindFaces to find a face to blur around). This could screw up the aspect ration because if the function thought there wasn't a face, than you'd get a  very zoomed in and blurred celebrity. So we turned to what any civil human being would do in this tragic scenario, and employed the services of Grumpy Cat.

Grumpy Cat, lord of the seven kingdoms, comes in handy for a lot of my project's corner cases haha. I've used Earl (the Grumpy Dog equivalent whom you should know about if you've ever been on the internet) too but this project was too important not to leave in the hands of a veteran(arian). <-- Someone give me five for that sick pun. Sick pun? Yes, another pun. A pun on a pun. How punderful... K, I'll stop.

In the case that the type of image returned by ImageIdentify is not a “person”, we put up a picture of GrumpyCat informing our visitor that we were not amused with their foolishness and to try again. Sometimes ImageIdentify won’t recognize you as a person if you take up a very small fraction of the photo, which works out in this case because the program enlarges and focuses on your face, so the end product of that would look all pixelated and bad.

c. The Ugly

If you did a timing test of our first round of the project, you would find that the average result would take 8 seconds. About 6 of those seconds were taken by our finding of the right celebrity to match you. Now in theory, yes this should take the longest because it needs to do some crazy sci-fi deep learning to figure out picture similarities, but actually it was because it was comparing your pictures to millions and millions of other images. See in the beginning we were using the function ImageIdentify, which does exactly what it sounds like. However that scope was much too broad and was slowing us down.

We gained some speed by narrowing the search to just "NotablePerson" - done by trying to Classify a picture of you amongst Notable People. If only you looked more Notable it would be easier!

But the truth is that the Classification of even 2000 people still takes an inordinate amount of time. We're just hoping that we won't lose too many users if it takes you 5 seconds to serve someone an image. Fingers crossed that you got that gigabit internet speed.

3. Putting it all together:

References: 

-API Code

-Image Upload To API Source Code

Okay so you've seen how the website and the core functionality were put together, but how are you going to link them? There are two main linking parts. The user drag'n'drops a photo that needs to get sent to the Wolfram function. The Wolfram function will process the image and spit out a result, which needs to get displayed on the results page.

a. The Good

The Wolfram Language is exceptionally good at creating quick APIs for you to mess around with. By using an iframe whose source is our Wolfram Language API, it is really easy to upload a picture to the Wolfram server to implement our core functionality. Below is the HTML iframe that does what we want:

The url you see here is the iframe to the “drag and drop” image. From there it is deployed to the API url like so:

Shifting to the Wolfram Language code to implement this (make sure to follow along in the referenced code), we simply make a function to do what want and CloudDeploy it as an APIFunction. The function will spit out a URL which is where, if sent the appropriate parameters for the function you made, take the parameters as input and execute your function.

For efficiency, we decided to take and store your input Image cached in a file and calculate the result using our core functionality. That way we can recreate the result if you want to come back to the results page. Don't worry about the specifics other than the storage of the result image allows for us to get it to display on the result page.

Here is the javascript code on the results page to grab the image and display it:

which goes here to get the image from the file url:

Big shout out to fellow employee Jeremy Davis, who got me going on the API code and wrote the javascript to make it all happen.

b. The Bad

As you might have seen from some of the early sites I had pointed out, I was using a web app making site called Heroku. Heroku is pretty cool as it lets you deploy and spin up web apps without needing a server. I think you get a free gig of storing space and five custom URLs per account. That being said, you need to make a bunch of files to tell heroku how to actually read your files. It is good for beginners (consider using Github Pages for static sites), but I think hosting your own apache server is better and more flexible. 

Having to pull and push to Heroku or your own serve was fine for awhile, though sometimes I might mess up the file hierarchy and have trouble adding new pages. To make it as efficient as possible I downloaded an app called Cyberduck which is a sweet desktop app that allows you to see where all of your code is stored in a window just like “finder”or “windows explorer.”

All you have to do is click and drag to edit files in Cyberduck! You should definitely purchase if you can, otherwise you can get it for free on their site.

c. The Ugly

Though we optimized the transfer process of the image between the original page and the results page by caching the image and storing the output, the process is still a little slow. Not only for the actual image to load, but also when you reload the page or send the link to a friend, the image is still retrieved every time from the Wolfram server before displaying. It would be great to be able store it statically on the page, but I’m still working on how to do that.

Lastly the result URL is just plain obscene! It’s like 100 characters long. Celebritymatch.io /result/BobHasATwin looks much better than the current one! Oh well, things to work on.

Conclusion

So after reading a much-detailed explanation of LookLike.Ai, what do you have to show for it? Well you’ve learned a lot about the Wolfram Language – you’ve learned how to interact with it, how to implement it, how to connect it to a web application, how to deploy it as a finished object or as an API. Hopefully I taught you at least one HTML or Javascript trick. And if you hadn’t heard of Cyberduck before then you’re welcome.

You might be wondering why we chose LookLike.Ai for the name of the site. And wonder you shall continue because why would I ever give away such a valuable secret! I very much encourage you to think about whether or not “Ai” is a purposeful misspelling or acronym – and maybe, just maybe, you’ll figure it out.

Go forth dear reader and code yourself an epic Wolfram Language app.

API’s and AP-Goodbye’s,

things we can find out about any university

9. Export - Convert any file to any other by using Export. Lets first import the new internet phenom Grumpy Dog Earl. As you can see at the end of the URL, Earl is a PNG (I resized him to be a bit smaller - 100px width). Then I export him with the suffix of my choice and we can open it by opening the file either with SystemOpen or by navigating to your file directory and getting the file there.

10. FindFaces - So many epic ideas will come to your mind with FindFaces. Ignore the gibberish again but basically for each face identified a nice red box is applied to it. Looks at all those celebs!

11. MovieData - Speaking of Movie Stars, MovieData has some great information on any film you want if you want to create the next IMDB.

12. URLFetch - Headers, Cookies, HTTP Responses, Oh My! If you’re into getting information about websites and crawling, there is a whole suite of things for you. Look at the documentation on this sucker: http://reference.wolfram.com/language/guide/URLManipulation.html

13. URLShorten - look up URLBuild too

14. InflationAdjust - If you had 5,000 British pounds today, how much would you have had the year that Columbus discovered America?

15. ChemicalData - You studying for a Chem Test any time soon?

16. CloudDeploy - Okay CloudDeploy is the bomb. This allows you to send any creation of yours to a clickable link (go to #28 to see how to embed your Wolfram Language creations in your personal website). Now if you go to the link (see below the picture) then you can see Earl in a link that terminates with and whose header is “dog”. CloudDeploy is tricky so look up in the documentation about how to send off API’s and Form Functions

Link: https://www.wolframcloud.com/objects/user-874811a9-16a9-484c-9346-4513ac69bd23/dog

17. PieChart3D - Damn that looks nice. It is even interactive (if you play with it live) and you can click each slice to see what it means. Range[5] just plots 5 random slice sizes

18. Encrypt - Using OpenSSL you can encrypt and decrypt messages. Use QR codes, pictures of cats, anything you want as your key! Read more here.

19. SendMail - Hello from my little doggie Earl! Make sure to set up the SendMail options properly in Preferences -> Internet Connectivity -> SendMail on Wolfram Desktop.

20. ScheduledTask - These are really cool. Akin to a “If This Then That” product, you can easily have something running in the background for you. In the task below I’ve asked Wolfram to send me an e-mail (to my WolframID) every day for three months (change the stuff in blue to your liking) that has the daily temperature. The temperature will be from the location I send the request originally - unless I specify otherwise.

21. FinancialData - For all the investment bankers out there - there are some cool widgets you can make with FinancialData. Besides making easy graphs of financial data over time, Properties of FinancialData include PE-ratio (“PERatio”), Industry sector (“Sector”) and price volatility over a 50 day range (“Volatility50Day”). Do FinancialData[”Properties”] to see them all.

22. CityData - Michael Scott from “The Office” is one of 75,809 people. Can think of some cool uses of GeoGraphics with CityData!

23. LanguageData - So I love datasets, sue me! “LargestCountry” in this case counts for the highest percentage of native speakers in the population.

24. Manipulate - This function is super intersting and allows you to set a variable that you can change in real time. It is really fun for all things Math-y but also has some cool other ways of messing with it. Check out the code for the third place “Wolfram One-Liner Competition” in which Yves Klett had to make a program in 140 characters or less! Check outt he video of the result.

25. API Function - Even lazier on API Function - not even a picture! Trust me when I say that this is super important to any project you make so I’d rather you get your facts right from Stephen Wolfram himself: http://reference.wolfram.com/language/ref/APIFunction.html

26. Sunrise - What time should I wake up on my next birthday in my home city such that I’ll be able to see the Sunrise? IDK, guess I’ll ask Wolfram. What if now I add a ScheduledTask to emit a Beep[] sound 10 minutes before sunrise on my birthday so I’ll wake up?!?!

27. SphericalPlot3D - Okay maybe not soooo useful but still really cool. You can represent symbols like theta with  “ /[Theta] “

p.s. if you’re still reading this post - I am honored but also ashamed that you haven’t thought of a million-dollar idea yet! Read the last few and then go forth and win at life.

28. EmbedCode - So you’ve made this killer widget. You’ve even cloud deployed it so anyone in all the seven kingdoms can see how epic it is. But you want to embed it to your personal website. Well, never fear Shakespeare because EmbedCode is here to save the day. Customize the HTML as needed, it’s a just a quick tag to get ya started.

29. WikipediaData - Okay this data set is lovely. Great for images (try “ImageList”) too. In this case though we take a quick trip over to Europe:

30. ImageKeypoints - This is where Wolfram Language starts to get beyond me! But you’re likely savvier than me and can do some cool stuff like this. See below stolen from the documentation. ImageKeypoints captures the pixels of an image that really matter.

31. TextRecognize - See ya later Adobe products. Add this within the Speak[] function to have it say the words out loud!

32. IFTTT - If This Then That, one of my favorite companies that allows you to make “recipes” for using things that happens, now has Wolfram integration with DataBin. You can put in any information and then use the Wolfram Language to display it.

Here is our selected IFTTT recipe:

text={{Text}}&user={{UserName}}&link={{LinkToTweet}}&at={{CreatedAt}}

Which Automatically save @BarackObama's tweets into a databin and then we generate a WordCloud of them:

WordCloud[DeleteStopwords[ StringDelete[ StringJoin[Values[Databin["5D6purWi"]]["text"]], {"http", "President", "Obama", "co"}]]]

Take a wild guess what has been trending recently on Obama’s Twitter?

33. SendMessage - Okay don’t hate me but I don’t have a Twitter so I can’t demonstrate this live but I’m told this works!

34. Epilog - Remember that cool 3D swirly thing we made earlier? Well with whatever graphic you might want to make you might want to tag it. Put some nice text on it or nice arrows or whatever you need! Use Epilog or Prolog

Wow you made it all the way to the bottom! Thank you for reading my good friend. Go make a dope project and hit me up at [email protected] (or if you need a rapid answer at [email protected]) for any questions you might have - I don’t bite and have all the free time in the world to make your Wolfram Projects a grand success.

“Staring at a computer screen for too long makes the whole world blind”                          -Ma-Hack-ma Ghandi

strikethrough should be a cornerstone of the Wolfram Language.

Couple thinks to note. WL is a language that has an incredible host of functions that do just about anything you want. They all start with a capital letter. Type some random letters and click on the information button to start searching documentation.

As you get to build a more in depth project you’ll realize that you’re writing very few lines of code, but using a ton of functions. Don’t let all the brackets confuse you in this simple one-liner that spits out a random pokemon: 

EntityValue[EntityValue[“Pokemon”,“RandomEntity”],{“Image”,“Name”}] 

whose output produces 

… it looks better like: 

EntityValue[     

               EntityValue[“Pokemon”,        

                                "RandomEntity"        

                                ],

               {“Image”,“Name”} 

               ] 

Trust me use your brackets and tabbing carefully. Luckily if you haven’t completed a bracket or your braces or off, one of them will appear in red.

Time to take off the training wheels sonny:

In the great words of the prophetic Nacho Libre, “Let’s get down to the nitty gritty.” Below I’ve listed the kinds of things that will make freakin sweet additions to your hack project.

A. Cloud Deploy (https://www.wolfram.com/language/fast-introduction-for-programmers/cloud-deployment/)

All you have to do is wrap your program inside of CloudDeploy[] and it will instantly deploy and create a unique link that can be sent to anybody with your program in it. This is epic for quick user feedback and testing. Check out and refresh this guy.

B. iFrame Embedding and others (https://reference.wolfram.com/language/ref/EmbedCode.html)

Built a really cool function in WL but want to include it in a larger project or put in a cute little bootstrap-aided webapp? Done. Wrap your program inside of EmbedCode[] to receive something like this"

<iframe src=“https://www.wolframcloud.com/objects/0e78b6b9-ccac-407e-b864-42425b032ce6?_embed=iframe” width=“600” height=“800” />

It is actually hard to copy/paste the iframe so download it and open it in a text editor for best copy/pasting. Play with width and height as you like.

Check out the documentation for Python and Java embedding too.

C. App please!

Your wish is WL’s command. Making an app requires literally no work. When you create the WolframCloud object (using CloudDeploy), it will automatically creates an app version of your project which you can see by downloading the WolframCloud app on iOS. For Android development, check out an example here: http://community.wolfram.com/groups/-/m/t/313920

All you have to do is add the line 

Permission -> “Public” 

before the ending CloudDeploy bracket to deploy to iOS. See below the code I wrote for an app that detects whether a plant is poisonous or not by identifying an image of the plant.

Ignore most everything except the public permissions. Setting the AppearanceRules are kind of like the CSS for Wolfram Language. The IconRules just let you pass it an image to be your icon for your app and the string above that is the title of the app.

D. ImageIdentify: A whole new world.

Speaking of PoisonousOrNot, please try out Wolfram’s sweet ImageIdentify function that takes an image and returns to you an object containing what the image is. Heck yes.

Life Hacks: Keyboard Shortcuts

Anyone who has used Terminal in the slightest know the advantages of shortcuts. And anyone who ever said “don’t cut corners” has clearly never met a hacker. Here are my top Wolfram Language shortcuts:

a. Getting output: -“Shift-Enter” computes whatever line you’ve written (no need to do it until you want an output. Things highlighted in blue need to compiled with this command)

“=“ to type natural language, and “Enter” to compute it (“Ctrl-=“ put natural language inside of a regular function)

At the end of a picture or complex nested functions type “//FullForm” or “//TreeForm” … consider it a good  debugging tool

Jazz Hands: Make it look good for demo

I have no choice here but to command you… to use command. On a Mac hit Command-4 to be able to annotate your code with beautiful formatting. Command-3, Command-2, etc. all amount to really nice formatting options for headers, sections, highlighting code. Each time you hit that, look to the right side of the screen to see the little bracket which is called your cell. Type whatever you want in your cell and then click beneath to go back to coding or get another cool format to talk about your creation. I believe on Windows its Alt-4, etc.



Data Dropping the Bass: That extra boom that makes you love it all

One thing that especially makes Wolfram unique is having access to one of the largest accumulations of information on planet earth. Want to make an app about volcanoes? Wolfram knows every one and you can map them super easily (google search this you lazy bum - I can’t hyperlink everything for you). Want to mess around with the stock market? Wolfram knows the value of every stock in real time. I dare you to see how many Wall Street-y things you can learn by typing in FinancialIndicator[All]. Answer: like 80 different options. This just shows off the “SimpleMovingAverage” option. 

And don’t forget about data drop: https://datadrop.wolframcloud.com/ . In this bad boy you can add whatever massive dataset you want (HINT: go to http://www.data.gov/). Create something called a databin, upload your data, make an instant API and then access it through WolframLanguage. Like Hardware? Set up a ScheduledTask to record some data and then upload it to your data bin and right into your WL app (yeah - y’all are ready for the abbreviation now).

On your own junior: don’t forget to write home!

Okay there are a million StackExchange and other examples of how to do everything you need in Wolfram Language. But, just like Swift over Objective-C in iOS dev, Wolfram Language is newer, better and different than Mathematica, but there isn’t as much documentation. But never fear, Shakespeare, if you do your search queries for “Wolfram Language” but instead just search “Mathemetica”, then you’re sure to find what you’re looking for. Wolfram Language’s syntax is incredibly close to Mathematica’s so you’ll have no problem using what you learned and applying it to Wolfram Language.

 TL;DR

Use WL engine to create something you know you can’t do and embed it in your Bootstrap web app

Make a WL program into a phone app (android easy peasy, iphone even easy peasier) in seconds

If you’re having trouble finding documentation online, add “Mathematica” to your search, that code works the same in WL

Stay classy, HackDiego,