Our host will accept questions in real time and pass them to three of our graphics experts. You can also submit your question when you register for the event.

We will be prepared to address questions on graphics and visualizations, similar to these:

• How can I add a drop shadow to my plot?
• How can I independently color different sides of a surface?
• How can I turn several locators on and off on a graphic with a mouse click?
• How can I make an x-y scatter plot with auxiliary histograms placed next to the x-y axes?
• How can I create an intertwined graphic like the one below?

The virtual event will be held Tuesday, May 22, from 11am to noon Eastern Daylight Time (EDT).

Virtual seats are limited—see the event schedule and register today!

This is a major new initiative for us to create the ultimate computation environment for finance. It builds on our existing computational technology with extra capabilities and professional support services.

As part of this, I spent some time interviewing finance customers in the city of London about what they liked and didn’t like about Mathematica, what they wanted, and why some of their colleagues didn’t use it.

It turned out to be an exercise in staying open-minded and listening—because while we are naturally most excited about all the great computation that we provide (including “finance” functionality), time and again the issues that mattered were the less glamorous workflow improvements.

We have been focused on improving workflows more generally, for example supporting great data analysis, statistics, and visualization with highly automated import and export and reporting. The flow from data to analysis to CDF report is now a smooth process.

But looking at the specific needs of one industry segment reveals further optimizations. The new Bloomberg feed link is one such example. Being able to flow live, trading quality data directly into a computation or to create a CDF where the charts update with the market has now become trivial because we took that extra step to make the connection seamless.

Applying one of our our core principles—to automate as much as possible—makes this feature particularly powerful. The link includes a parameter discovery interface that automatically generates API code. This means that, armed with a new trading idea, you can prototype fast with our analysis capabilities and just paste in the generated code to call to the live data, and you can be ready to trade your new idea in minutes. Feed that into some of the built-in visualizations, and you can have a live CDF-powered dashboard to watch in just a few more minutes. One message I have been hearing repeatedly is that this kind of “algorithmic agility” is a key competitive advantage in finance.

Check out the new Wolfram Finance Platform, and watch this space for further improvements to both finance functionality and other optimized workflows that are in Wolfram Finance Platform‘s development pipeline.

Today ten years have passed since A New Kind of Science (“the NKS book”) was published. But in many ways the development that started with the book is still only just beginning. And over the next several decades I think its effects will inexorably become ever more obvious and important.

Indeed, even at an everyday level I expect that in time there will be all sorts of visible reminders of NKS all around us. Today we are continually exposed to technology and engineering that is directly descended from the development of the mathematical approach to science that began in earnest three centuries ago. Sometime hence I believe a large portion of our technology will instead come from NKS ideas. It will not be created incrementally from components whose behavior we can analyze with traditional mathematics and related methods. Rather it will in effect be “mined” by searching the abstract computational universe of possible simple programs.

And even at a visual level this will have obvious consequences. For today’s technological systems tend to be full of simple geometrical shapes (like beams and boxes) and simple patterns of behavior that we can readily understand and analyze. But when our technology comes from NKS and from mining the computational universe there will not be such obvious simplicity. Instead, even though the underlying rules will often be quite simple, the overall behavior that we see will often be in a sense irreducibly complex.

So as one small indication of what is to come—and as part of celebrating the first decade of A New Kind of Science—starting today, when Wolfram|Alpha is computing, it will no longer display a simple rotating geometric shape, but will instead run a simple program (currently, a 2D cellular automaton) from the computational universe found by searching for a system with the right kind of visually engaging behavior.

This doesn’t look like the typical output of an engineering design process. There’s something much more “organic” and “natural” about it. And in a sense this is a direct example of what launched my work on A New Kind of Science three decades ago. The traditional mathematical approach to science has had great success in letting us understand systems in nature and elsewhere whose behavior shows a certain regularity and simplicity. But I was interested in finding ways to model the many kinds of systems that we see throughout the natural world whose behavior is much more complex.

And my key realization was that the computational universe of simple programs (such as cellular automata) provides an immensely rich source for such modeling. Traditional intuition would have led us to think that simple programs would always somehow have simple behavior. But my first crucial discovery was that this is not the case, and that in fact even remarkably simple programs can produce extremely complex behavior—that reproduces all sorts of phenomena we see in nature.

And it was from this beginning—over the course of nearly 20 years—that I developed the ideas and results in A New Kind of Science. The book focused on studying the abstract science of the computational universe—its phenomena and principles—and showing how this helps us make progress on a whole variety of problems in science. But from the foundations laid down in the book much else can be built—not least a new kind of technology.

This is already off to a good start, and over the next decade or two I expect dramatic progress in the application of NKS to all sorts of technology. In a typical case, one will start from some objective one wants to achieve. Then, either through knowledge of the basic science of the computational universe, or by some kind of explicit search, one will find a system that achieves this objective—often in ways no human would ever imagine or come up with. We have done this countless times over the years for algorithms used in Mathematica and Wolfram|Alpha. But the same approach applies not just to programs implemented in software, but also to all kinds of other structures and processes.

Today our technological world is full of periodic patterns and other simple forms. But rarely will these ultimately be the best ways to achieve the objectives for which they are intended. And with NKS, by mining the computational universe, we have access to a much broader set of possibilities—which to us will typically look much more complex and perhaps random.

How does this relate to the kinds of patterns and forms that we see in nature? One of the discoveries of NKS is that nature samples a broader swath of the computational universe than we reach with typical methods of mathematics or engineering. But it too is limited, whether because natural selection tends to favor incremental change, or because some physical process just follows one particular rule. But when we create technology, we are free to sample the whole computational universe—so in a sense we can greatly generalize the mechanisms that nature uses.

Some of the consequences of this will be readily visible in the actual forms of technological objects we use. But many more will involve internal structures and processes. And here we will often see the consequences of a central discovery of NKS: the Principle of Computational Equivalence—which implies that even when the underlying rules or components of a system are simple, the behavior of the system can correspond to a computation that is essentially as sophisticated as anything. And one thing this means is that a huge range of systems are capable in effect not just of acting in one particular way, but of being programmed to act in almost arbitrary ways.

Today most mechanical systems we have are built for quite specific purposes. But in the future I have no doubt that with NKS approaches, it will for instance become common to see arbitrarily “programmable” mechanical systems. One example I expect will be modular robots consisting of large numbers of fairly simple and probably identical elements, in which almost any mechanical action can be achieved by an appropriate sequence of small-scale motions, typically combined in ways that were found by mining the computational universe.

Similar things will happen at a molecular level too. For example, today we tend to have bulk materials that are either perfect periodic crystals, or have atoms arranged in a random amorphous way. NKS implies that there can also be “computational materials” that are grown by simple underlying rules, but which end up with much more elaborate patterns of atoms—with all sorts of bizarre and potentially extremely useful properties.

When it comes to computing, we might think that to have a system at a molecular scale act as a computer we would need to find microscopic analogs of all the usual elements that exist in today’s electronic computers. But what NKS shows us is that in fact there can be much simpler elements—more readily achievable with molecules—that nevertheless support computation, and for which the effort of compiling from current traditional forms of computation is not even too great.

An important application of these kinds of ideas is in medicine. Biology is essentially the only existing example where something akin to molecular-scale computation already occurs. But existing drugs tend to operate only in very simple ways, for example just binding to a fixed molecular target. But with NKS methods one can expect instead to create “algorithmic drugs”, that in effect do a computation to determine how they should act—and can also be programmable for different cases.

NKS will also no doubt be important in figuring out how to set up synthetic biological organisms. Many processes in existing organisms are probably best understood in terms of simple programs and NKS ideas. And when it comes to creating new biological mechanisms, NKS methods are the obvious way to take underlying molecular biology and find schemes for building sophisticated functionality on the basis of it.

Biology gives us ways to create particular kinds of molecular structures, like proteins. But I suspect that with NKS methods it will finally be possible to build an essentially universal constructor, that can in effect be programmed to make an almost arbitrary structure out of atoms. The form of this universal constructor will no doubt be found by searching the computational universe—and its operation will likely be nothing close to anything one would recognize from traditional engineering practice.

An important feature of NKS methods is that they dramatically change the economics of invention and creativity. In the past, to create or invent something new and original has always required explicit human effort. But now the computational universe in effect gives us an inexhaustible supply of new, original, material. And one consequence of this is that it makes all sorts of mass customization broadly feasible.

There are many immediate examples of this in art. WolframTones did it for simple musical pieces. One can also do it for all sorts of visual patterns—perhaps ever changing, and selected from the computational universe and then grown to fit into particular spatial or other constraints. And then there is architecture. Where one can expect to discover in the computational universe new forms that can be used to create all sorts of structures. And indeed in the future I would not be surprised if at first the most visually obvious everyday examples of NKS were forms of things like buildings, their dynamics, decoration and structure.

Mass production and the legacy of the industrial revolution have led to a certain obvious orderliness to our world today—with many copies of identical products, precisely repeating processes, and so on. And while this is a convenient way to set things up if one must be guided by traditional mathematics and the like, NKS suggests that things could be much richer. Instead of just carrying out some processes in a precisely repeating way, one computes what to do in each case. And putting together many such pieces of computation the behavior of the system as a whole can be highly complex. And finding the correct rules for each element—to achieve some set of overall objectives—is no doubt best done by studying and searching the computational universe of possibilities.

Viewed from the outside, some of the best evidence for the presence of our civilization on Earth comes from the regularities that we have created (straight roads, things happening at definite times, radio carrier signals, satellite orbits, and so on). But in the future, with the help of NKS methods, more and more of these regularities will be optimized out. Vehicles will move in optimized patterns, radio signals will be transferred in complicated sequences of local hops… and even though the underlying rules may be simple, the actual behavior that is seen will look highly complex—and much more like all sorts of systems in physics and elsewhere that we already see in nature.

There are other—more abstract—situations where computation and NKS ideas will no doubt become increasingly important. One example is in commerce. Already there is an increasing trend toward algorithmic pricing. Increasingly commercial terms and contracts of all kinds will be stated in computational terms. And then—a little like a market of algorithmic traders—there will be what amounts to an NKS issue of what the overall consequences of many separate transactions will be. And again, finding the appropriate rules for these underlying transactions will involve understanding and searching the computational universe—and presumably various kinds of mass customization, that eventually make concepts like money as a simple numerical quantity quite obsolete.

Future schemes for such things as auctions and voting may also perhaps be mined from the computational universe, and as a result may be mass customized on demand. And, more speculatively, the same might be true for future corporate or political organizational structures. Or for example for mechanisms for social and other human networks.

In addition to using NKS in “technology mode” as a way to create things, one can also use NKS in “science mode” as a way to model and understand things. And typically the goal is to find in the computational universe some simple program whose behavior captures the essence of whatever system or phenomenon one is trying to analyze. This was an important focus of the NKS book, and has been a major theme in the past decade of NKS research. In general in science it has been difficult to come up with new models for things. But the computational universe is an unprecedentedly rich source—and I would expect that before long the rate of new models derived from it will come to far exceed all those from traditional mathematical and other sources.

An important trend in today’s world is the availability of more and more data, often collected with automated sensors, or in some otherwise automated way. Often—as we see in many areas of Wolfram|Alpha or in experiments on personal analytics—there are tantalizing regularities in the data. But the challenge that now exists is to find good models for the data. Sometimes these models are important for basic science; more often they are important for practical purposes of prediction, anomaly detection, pattern matching and so on.

In the past, one might find a model from data by using statistics or machine learning in effect to fit parameters of some formula or algorithm. But NKS suggests that instead one should try to find in the computational universe some set of underlying rules that can be run to simulate the essence of whatever generates the data. At present, the methods we have for finding models in the computational universe are still fairly ad hoc. But in time it will no doubt be possible to streamline this process, and to develop some kind of highly systematic methodology—a rough analog of the historical progression from calculus to statistics.

There are many areas where it is clear that NKS models will be important—perhaps because the phenomenon being modeled is too complex for traditional approaches, or perhaps because, as is becoming so common in practice, the underlying system has elements that are specifically set up to be computational.

One area where NKS models seem likely to be particularly important is medicine. In the past, most disorders that medicine successfully addressed were fundamentally either structural or chemical. But today’s most important challenge areas—like aging, cancer, immune response and brain functioning—all seem to be associated more with large-scale systems containing many interacting parts. And it certainly seems plausible that the best models for these systems will be based on simple programs that exist in the computational universe.

In recent times, medicine has slowly been becoming more quantitative. But somehow it is still always based on small collections of numbers, that lead to a small set of possible diagnoses. But between the coming wave of automated data acquisition, and the use of underlying NKS models, I suspect that the future of medicine will be more about dynamic computation than about specific discrete diagnoses. But even given a good predictive model of what is going on in a particular medical situation, it will still often be a challenge to figure out just what intervention to make—though the character of this problem will no doubt change when algorithmic drugs and computational materials exist.

What would be the most spectacular success for NKS models? Perhaps models that lead to an understanding of aging, or cancer. Perhaps more accurate models for social or economic processes. Or perhaps a final fundamental theory of physics.

In the NKS book, I started looking at what might be involved in finding the underlying rules for our physical universe out in the computational universe. I developed some network-based models that operate in a sense below space and time, and from which I was already able to derive some surprisingly interesting features of physics as we know it. Of course, we have no guarantee that our physical universe has rules that are simple enough to be found, say, by an explicit search in the computational universe. But over the past decade I have slowly been building up the rather large software and analysis capabilities necessary to mount a serious search. And if successful, this will certainly be an important piece of validation for the NKS approach—as well as being an important moment for science in general.

Beyond science and technology, another important consequence of a new worldview like NKS is the effect that it can have on everyday thinking. And certainly the mathematical approach to science has had a profound effect on how we think about all kinds of issues and processes. For today, whether we’re talking about business or psychology or journalism, we end up using words and ideas—like “momentum” and “exponential”—that come directly from this approach. Already there are analogs from NKS that are increasingly used—like “computationally irreducible” and “intrinsically random”. And as such concepts become more widespread they will inform thinking about more and more things—whether it’s describing the operation of an organization, or working out what could conceivably be predictable for purposes of liability.

Beyond everyday thinking, the ideas and results of NKS will also no doubt have increasing influence on many areas of philosophical thinking. In the past, most of the understanding for what science could contribute to philosophy came from the mathematical approach to science. But now the new concepts and results in NKS in a sense provide a large number of new “raw facts” from which philosophy can operate.

The principles of NKS are important not only at an intellectual level, but also at a practical level. For they give us ideas about what might be possible, and what might not. For example, the Principle of Computational Equivalence in effect implies that there can be nothing general and abstract that is special about intelligence, and that in effect all its features must just be reflections of computation. And it is this that made me realize soon after the NKS book appeared that my long-term goal of making knowledge broadly computable might be achievable “just with computation”—which is what led me to embark on the Wolfram|Alpha project.

I have talked elsewhere about some of the consequences of the principles of NKS for the long-range future of the human condition. But suffice it to say here that we can expect an increasing delegation of human intellectual activities to computational systems—but with ultimate purposes still of necessity defined by humans and the history of human culture and civilization. And perhaps the place where NKS principles will enter most explicitly is in making future legal and other distinctions about what really constitutes responsibility, or a mind, or a memory as opposed to a computation.

As we look at the future of history, there are some inexorable trends, and then there are some wild cards. If we find the fundamental theory of physics, will we be able to hack it to achieve something like instantaneous travel? Will we find some key principle that lets us reverse aging? Will we be able to map memories directly from one brain to another, without the intermediate step of language? Will we find extraterrestrial intelligence? About all these questions, NKS has much to say.

If we look back at the mathematical approach to science, one of its societal consequences has been the injection of mathematics into education. To some extent, a knowledge of mathematical principles is necessary to interact with the world as it exists today. It is also an important foundation for understanding fields that have made serious use of the mathematical approach to science. And certainly learning mathematics to at least some level is a convenient way to teach precise structured thinking in general.

But I believe NKS also has much to contribute to education. At an elementary level, it can be viewed as a kind of “pre-computer science”, introducing fundamental notions of computation in a direct and often visual way. At a more sophisticated level, NKS provides a conceptual framework for understanding the foundations of many computational fields. And even from what I have seen over the past decade, education about NKS—a little like physics before it—seems to provide a powerful springboard for people entering all sorts of modern areas.

What about NKS research? There is much to be done in the many applications of NKS. But there is also much to be done in pure NKS—studying the basic science of the computational universe. The NKS book—and the decade of research that has followed it—has only just begun to scratch the surface in exploring and investigating the vast range of possible simple programs. The situation is in some ways a little like in chemistry—where there are an infinite variety of possible chemical compounds each with their own features, that can be studied either for their own sake, or for the purpose of inferring general principles, or for diverse potential applications. And where even after a century or more, only a small part of what is possible has been done.

In the computational universe it is quite remarkable how much can be said about almost any simple program with nontrivial behavior. And the more one knows about a given program, the more potential there is to find interesting applications of it, whether for modeling, technology, art or whatever. Sometimes there are features of programs that can be almost arbitrarily difficult to determine. But sometimes they can be important. And so, for example, it will be important to get more evidence for (or against) the Principle of Computational Equivalence by trying to establish computation universality for a variety of simple programs (rule 30 would be a particularly important achievement).

As more is done in pure NKS, so its methodologies will become more streamlined. And for example there will be ever clearer principles and conventions for what constitutes a good computer experiment, and how the results of investigations on simple programs should be communicated. There are fields other than NKS—notably mathematics—where computer experiments also make sense. But my guess is that the kind of exploratory computer experimentation that is a hallmark of pure NKS will always end up largely classified as pure NKS, even if its subject matter is quite mathematical.

If one looks at the future of NKS research, an important issue is how it is structured in the world. Some part of it—like for mathematics—may be driven by education. Some part may be driven by applications, and their commercial success. But in the long term just how the pure basic science of NKS should be conducted is not yet clear. Should there be prizes? Institutions? Socially oriented value systems? As a young field NKS has the potential to take some novel approaches.

For an intellectual framework of the magnitude of NKS, a decade is a very short time. And as I write this post, I realize anew just how great the potential of NKS is. I am proud of the part I played in launching NKS, and I look forward to watching and participating in its progress for many years to come.

Thousands of people follow @MathematicaTip to get a new tip every day, Monday through Friday, covering everything from keyboard shortcuts:

Instead of using % to refer to the most recent output, try Ctrl+Shift+L (Mac: Cmd+Shift+L) to directly insert the output from above.

— MathematicaTip (@MathematicaTip) October 10, 2011

To programming:

x /. r applies the rules r to x once. x //. r applies the rules repeatedly: f[a b c] //. f[x_ y_] -> f[x] + f[y]. http://j.mp/iXIjVE

— MathematicaTip (@MathematicaTip) June 3, 2011

To graphics, neat examples, and more:

Visualize HSB color space: Graphics3D[{Hue[#], Cuboid[#, # + .1]} & /@ Tuples[Range[0, 1, .2], 3], Lighting->”Neutral”] twitter.com/MathematicaTip…

— MathematicaTip (@MathematicaTip) February 3, 2012

Starting this week we’re counting down the top 10 most popular tips from our first year. Follow along on Twitter at @MathematicaTip. (You can also follow using an RSS feed.) You can view the full archive of daily Mathematica tips from our Twitter page.

During my years as a graduate student I had the chance to live in three different countries and experience different working environments: other than my native Italy, I lived in Paris, where my PhD was based at ENS, and in Princeton, where I was lucky enough to spend time at the Institute for Advanced Study. However, at the end of my PhD, I felt that most of my interest in what I was doing was gone and that I needed to try something new.

Once at the Summer School, I had the chance to meet and chat with Stephen Wolfram as he helped me come up with a problem to work on. One of the first things I told him was that I was weary of open-ended academic kinds of problems and I was afraid no one was ever going to read my papers. I said that I wanted to deal with intellectual challenges, but I also wanted to tackle something that had a clear beginning and end.

His reply came as a disappointment, since what he suggested I work on was both completely outside my area of expertise and clearly one of those impossibly wide problems that I was now skeptical of. What did he say?

Stephen asked me to devise a system to generate a plain English description of a time series. My disappointment vanished quickly when I realized that while a general answer to this kind of question was well beyond the scope of the three weeks I had at the Summer School, there was a combination of neat heuristics and information theory ideas that might do a reasonable job in most cases.

Little did I know that I loved this kind of experimental coding and that it was going to become my full-time job as a Wolfram employee a few months later. My project turned out to be a success, and soon I was encouraged to apply for a job at Wolfram Research, the company that made Mathematica–a product my friends and I had long considered a godsend for our work.

In my first four months at the company, I got involved in a very exciting project that has taken Wolfram|Alpha in an entirely new direction. I worked in a small group on what was known internally by the name tabular input (or TI to its friends). Along with image upload, file upload, and data download, TI formed one of the foundations of our subscription service, Wolfram|Alpha Pro.

The idea behind this project was to treat data as if it were language: columns of a single type of data, like numbers, dates, places, or what have you, act as words in a sentence. And just like sentences of human language, groups of these words are more than the sum of their parts. To give a particularly important example, think about a time series, which is a column of dates plus a column of one or more numeric quantities.

We knew we had at our disposal a huge amount of data coming from Wolfram|Alpha as well as the power of the parser to recognize what this data was all about. We could parse dates in any format, various currencies, and units. This made it natural to think along these lines: This column is about currency. It appears alongside a column of dates. We happen to have data about inflation in that country. We can do an inflation adjustment on the currency values!

So we had the notion of parsing data to determine what kinds of analysis to perform. What about those analyses? How should they look and feel? How should we rank them if many different ones were possible?

Now, along with a small group of smart people coming from wildly different backgrounds–economics, computational biology, pure math, and statistics, to mention a few–we started thinking about what this new data language was trying to say. (Interestingly, most of these people were Summer School alumni from several past years.)

A key fact about our group was that, while everyone had the vocabulary of mathematics in common, no single person knew it all. Take me, for example. As a physicist, I am perfectly at ease with nonlinear fits, but I couldn’t read a regression table to save my life! But to my colleague, an economist, regression tables were second nature.

And in arguing about how to display these results in a way that made sense to a non-expert and an expert both, we got to the crux of each analysis. In fact, this was also how I came up with the idea of spelling out in plain English the key results of our data analysis and, so, funnily enough, this is where my Summer School project came full circle.

For example, one of the sample datasets was the passenger list from the Titanic: age, class, gender, and whether or not they had made it to the lifeboats. Now, a logistic regression is the perfect tool to see if being a woman or a child actually increased the chances of surviving, but can you actually interpret one? As you can see below, we’ve done the job for you! And in case you were wondering what the result is, you had a better chance of survival if you were female, young, and a first-class passenger.

Each one of us had to think: “What would I, as an expert in this field, do with this data? How would I visualize it? What kind of analysis would I perform on it?” It turns out this is one of the key insights of Wolfram|Alpha: to bring expert knowledge to the tips of everybody’s fingers (or vocal cords, if you happen to use Siri).

What I ended up finding really addictive about this job is that I get to wrap my mind around research-grade problems, but after I understand them, I have to quite quickly turn my ideas into workable features of a website that is used by a lot of people daily. At Wolfram, I get the intellectual challenge I was looking for, and thousands read my research results every day.

Now you can easily embed any Demonstration you like on your own blog or website in one step. Watch this short video or read on to see how (we recommend viewing the video in full-screen mode):

Each Demonstration page includes a snippet of JavaScript code in the Share section of the sidebar.

Just copy and paste the code into your website or blog to put the live Demonstration on your site. Anyone who has the Wolfram CDF Player installed will be able to interact with it, just like this one.

The embed code also provides the author’s name and title, as well as convenient links to the Demonstrations site and the CDF Player download site. If you’re an author, that greatly increases the visibility of your work on the web and helps promote your ideas.

The Demonstrations Project aims to bring computational exploration to the widest possible audience, and this makes it even easier to broadly share your ideas.

Try it out and let us know what you think. We would love to see what you share, so please leave a comment with a link to your blog or site with live Demonstrations.

We will start with a short program that numerically solves the challenging problem of constrained global optimization by finding the minimum on a limited surface region. Think of finding the lowest point of an area of a mountain range. Dragging the 2D slider on the interface below automatically changes the surface geometry, and the CDF engine quickly recomputes the new minimum. This is reflected in the updated positions of the red dot. Drag and rotate the 3D graphics with the mouse to get a different view. Hold Ctrl while dragging to zoom (Command on a Mac) or hold Shift and drag to pan.

The code is compact because Mathematica‘s extensive library provides thousands of built-in functions that target a wide scope of tasks. The code is also easily readable because of consistent syntax and meaningful function names. Even a novice user would be able to come up with a similar program in a fairly short time using our extensive documentation full of typical examples. Note that I did not have to program the numerical optimization algorithms packed in the function NMinimize or the interface automatically constructed by Manipulate. While NMinimize is highly automated, I also had the freedom to specify the numerical method I prefer, using the option Method → "RandomSearch". Most of the styling, such as meshes, ranges, ticks, and so on, is also done automatically. Mathematica‘s interactive 2D and 3D graphics are far superior to what most current publishing platforms can offer. As you change the surface, Manipulate forces dynamic updates, constantly running the algorithms of NMinimize. All that in just few lines of code.

Next we will see how the ideas behind CDF scale up when the complexity of our goals grows and many parts need to come together in a single, perfectly working whole. As a case study, consider the Game of Life, which, in addition to its recreational fame, is a powerful scientific example of complex behavior rising from simple rules. (For a deeper insight into this and other simple programs, read Stephen Wolfram’s book A New Kind of Science and apply for the 10th Annual Wolfram Science Summer School.)

Scroll down and click “run” to start the simulation.

If you are familiar with the Game of Life, you probably recognize immediately that this is not its typical implementation. Only black cells represent the usual evolution, while the colorful background is the 2D Fourier power spectrum computed in real time on the changing patterns of black cells. Notice the dramatic change in the Fourier plot when two moving black configurations come close together. Such signatures in the Fourier space can be used for the detection of collisions and close proximity between structures, leading to significant computational speedup compared to the blunt search in original data space. We may gain many other insights into properties of the driving rules and emerging patterns by using built-in Mathematica signal processing tools. This instructive, simultaneous visualization is possible thanks to the function Overlay, a useful construct able to overlap all types of expressions and even preserve interactivity by overlaying controls.

At the end of the code above, there is a nested list of integers representing well-known Game of Life patterns. Simulate them by clicking one of the “preset” buttons followed by “run.” Using SparseArray, I was able to compress the data in these patterns to one third of the original ByteCount. The uncompressing function is included at the beginning of the numbers list. This inclusion of custom data in CDF was done with Manipulate‘s Initialization option. Another way to add data to your CDF document is to use built-in Mathematica data and calls to the WolframAlpha function to access more than 10 trillion pieces of data in our constantly updating curated database.

In addition to automated interfaces with the standard arsenal of sliders, buttons, menus, and numerous other controls, custom interactivity and dynamics are also supported. This gives a lot of room for improvisation, but does not really require much effort. In the code above, it is achieved with the built-in function EventHandler, which manages inputs from the keyboard, mouse, and other devices. It is clear from the code that the MouseClicked event is tracked. Go ahead and color in some cells with mouse clicks. Use the button “random” to fill many cells together.

The Game of Life evolves according to simple mathematical rules packed in the function CellularAutomaton. But what makes it run here? There are no “Do” or “For” loops. The answer is that Manipulate is a dynamic function. It automatically updates if any of its tracked variables change. Therefore, if changing x causes x to change (a recursive definition of the type x=F[x]), Manipulate will continuously update until x settles to a stationary point. This is exactly the case here, as can be seen from the first few lines of code. The stationary point is reached (updating stops) when x=F[x] is satisfied. We took advantage of this in the first argument of Switch (literally, x=x), allowing us to “pause.” This technique of using simple recursive definitions inside dynamic functions comes in quite handy for long-running simulations and animations when you do not want to store all the history of variable values. There are a few other neat tricks in this CDF file. For example, the “size” slider is disabled in “pause”/”run” modes to protect currently evolving configurations. This is reflected with a slightly different visual appearance of the slider, a nice interface element that, again, was not explicitly coded, but purely automated by the option Enabled.

This app has plenty of potential for further development. With slight syntax changes to the function CellularAutomaton, it is possible to produce the evolution of a huge number of other interesting algorithms different from the Game of Life and easy to generalize to spaces other than 2D grids. The same holds for many other built-in Mathematica functions. And what requires a slight change of syntax in Mathematica typically requires writing many more lines of code from scratch in other languages.

Our last example will demonstrate the reusability of Mathematica code. More than 7,800 CDFs available at the Wolfram Demonstrations Project show the diversity of approaches to authoring ideas with interactive interfaces. The Demonstrations Project is the largest free online electronic publishing system dedicated solely to open-source code, interactive in-browser documents, and illustrations of scientific concepts. It continues to grow with submissions from users like you, providing freely downloadable code for learning and reusing. Below is my version of the elegant “Tree Bender” by Theodore Gray. By injecting randomness into the original, purely deterministic fractal and adding just a touch of styling, we can get quite close to producing artistic illustrations. Download the CDF version of this post below to see the minimal code changes I made to the original. The main difference compared to the original code comes from quite a few RandomReal functions in my version. They are pseudorandom number generators and change the appearance of the original regular shapes to random, more natural-looking trees. One million basic random tree samples are controlled by the “environment” slider, which uses SeedRandom to reset the pseudorandom generators. Basic trees are further customizable with the rest of the controls, including the small, green, movable circles on the plot. The interface was meant to be self-explanatory, so go ahead and explore. There are more than 300 quintillion trees in one small CDF file!

CDF documents run the same computational engine as Mathematica, installed on multitudes of computers in universities, companies, and organizations around the world, the engine that has powered scientific research for more than 20 years.

To learn about the full scope of CDF possibilities from our leading experts and authors, register for the Wolfram CDF Virtual Workshop.

Download this post as a Computable Document Format (CDF) file.

Now we’re holding a virtual workshop where you can hear from the author of an award-winning CDF textbook, chat with Wolfram experts in publishing and application development, and learn how to get started with your own projects.

The Wolfram CDF Virtual Workshop will feature a keynote by Conrad Wolfram plus talks and Q&A sessions with Wolfram experts.

The virtual event will be held Tuesday, April 24, at the following times:
* 8am–noon Eastern Daylight Time (EDT); 1pm–5pm British Summer Time (BST)
* Repeat session: 1pm–5pm EDT; 6pm–10pm BST

Virtual seats are limited—see the event schedule and register today!

Naturally, we did all the data cleaning and analysis for Stephen’s data in Mathematica, so we’ll be using Mathematica for everything here as well. All the code can be downloaded here.

Let’s start with that really cool diurnal plot Stephen did of his outgoing email. This plot shows the date and time each email was sent, with years running along the x axis and times of day on the y axis:

To make this plot, we first need to import our email into Mathematica. There are lots of ways to do this, depending on the details of your email server and so on, but for the purposes of this blog post I’ve written a simple function that imports mail from an IMAP mail server:

This function uses J/Link to call the JavaMail library, included in the download, for connecting to your mailbox and downloading emails from it.

You call the function with the name of the IMAP server and the name of the mail folder you want to import mail from. Here I’m importing the emails from my Sent Mail folder in my Gmail account:

When you evaluate this line, a dialog window will pop up that asks you for your email address and password:

After entering your email address and password in the input fields, the function will return a list of dates that were parsed from the time stamps on each email:

I’ll do the same thing for my incoming mail, this time specifying the folder name Inbox:

Now that we have the email time stamps, we can reproduce almost every single plot in Stephen’s blog post!

Let’s start with the diurnal plot. Here’s a function that takes a list of dates and uses the function DateListPlot to plot a point for each email sent:

Clearly I send a lot less email than Stephen Wolfram does! Still, there are some patterns visible here. The density is clearly higher around 2007–2008, with a rather sharp looking drop-off in mid-2008 (hmm, what happened in mid-2008?). There is a well-defined “sleep band” in the plot from around 1am to 9am or so, as I would expect, but I clearly sent less mail after midnight after around 2010. And now that I think about it, that’s right around when I started going to the gym in the mornings, so that makes sense.

The little burst of emails that are being sent in the middle of the night in mid-2009 aren’t actually a period of insomnia: I was in Italy lecturing at the 2009 Wolfram Science Summer School, so my time zone was shifted by +7 hours. Since I didn’t bother to change the time zone in my Gmail settings while I was away, all the emails I sent continued to be stamped with my regular time zone. So if I sent mail at midnight in Italy, the email time stamp said something like 5am local time.

Let’s see what my incoming mail looks like:

I receive a LOT more email than I send! There are some interesting patterns here as well. One obvious feature is the daily automated emails I received for certain periods of time, which appear as perfectly straight streaks in the diurnal plot, since they get sent automatically at the same time of day each day.

Now I want to compare the number of emails I’ve sent and received as a function of time. So let’s use DateListPlot again to plot the time series of incoming and outgoing emails superimposed (the code for this plot and all subsequent plots is in the attached notebook):

There’s definitely a correlation between the number of incoming and outgoing emails at any given time: when incoming email is high, outgoing tends to be high as well. That’s probably because when I receive more emails, I send more emails in response (as opposed to me initiating more discussions and causing more incoming replies)—but to find out for sure I’d need to analyze the email threads in detail.

We can also plot the daily incoming and outgoing mail with the monthly average:

These time series plots show my emailing behavior on timescales of years, but we can also look at the distribution of emails sent by time of day. Here’s the daily distribution for my sent mail:

It looks like I send the majority of emails between 10pm and midnight, which makes sense because I mainly use Gmail for personal stuff in the evenings. The daily distribution of incoming mail is a lot flatter:

There’s a hint of a dip in the incoming mail around 6pm, where presumably people in my time zone are having their dinner. Then of course there’s a sharp drop after midnight when most people are asleep.

How many emails do I typically send in a day? I can find out by plotting the distribution of emails sent per day, with the number of emails sent per day on the x axis and the count on the y axis:

Here’s the raw data:

The distribution peaks sharply at zero, which means I most often send no emails in a day (from my Gmail account that is). I’m a low-frequency emailer apparently! The distribution of incoming mail per day is more interesting looking:

This looks like it could be a negative binomial distribution:

It’s fun to think about what this kind of distribution implies about the underlying process of receiving email. The standard interpretation of the negative binomial distribution NegativeBinomialDistribution[n,p] is the probability in a series of n + k trials that k failures happen before n successes occur, where the probability of success for each trial is p. It’s not immediately clear whether that’s a good model for the number of emails I receive in a day. What would the individual Bernoulli trials correspond to? (Actually, the fit is a little better to a beta negative binomial distribution, which allows the success probability p to vary over a beta distribution.)

We did all this analysis just using email time stamps! And it’s just the tip of the iceberg of what it’s possible to do with your email archive. You could import the email addresses on each email to see whom you email most often and how your most common recipients have changed over time. Or you could correlate sent mail to received mail to track message threads and plot things like thread length distribution or time delay in responding to emails. When you’re doing your analysis in Mathematica, the possibilities are endless.

You can find all the code I used in this post right here. Have fun!

Download this post as a Computable Document Format (CDF) file.

The concept that came out of the short brainstorming meeting was to have a button on an iPad that would trigger a video on our display board, leading to an image showing facts about the world at the moment of revelation.

This is the story of how we made it happen.

I start with a disclaimer—this is not an example of elegant coding or optimal use of Mathematica, but is a real-life story of implementing an under-specified idea (subject to feature creep) quickly and with no regard for future maintenance—in short, like a lot of software projects.

Jeremy Davis, Wolfram’s Design Director, quickly produced a mockup in Photoshop of what it might look like while I set about building the data extraction code.

I knew that pulling data from Wolfram|Alpha and visualizing it would be easy, but what occupied my thoughts were the potential network failures, Wolfram|Alpha failures, local CPU overloads, or other horrors that could transpire to embarrass me in front of the PM!

So I started with a function that would query Wolfram|Alpha with a failure mode that would return a previous query result if no valid answer came within 20 seconds:

Likewise, here is a version of First, which won’t complain if there is no first element, but will instead return something invisible.

Anticipating that the design and color scheme would change repeatedly (though in the end it never did), I separated out the style choices:

To get the right arguments for the WolframAlpha function, the easiest way is to do a full linguistic query from the notebook by entering == followed by the query. If you then click in the pod corner and select either “Subpod content” or “Computable data” from the popup menu, you get the API code generated for you automatically.

For example, the parameters for our current local weather are "weather oxford",{{"InstantaneousWeather:WeatherData",1},"ComputableData"}. With some styling and text substitution, I end up with this code for generating the final image pod:

The ImageCrop part I will explain in a minute.

Images are a little trickier, as Wolfram|Alpha returns the Computable Document Format (CDF) structure of the image rather than the semantic structure. So I first used ToExpression to turn it into a meaningful Graphics expression, and then used replacement rules to swap out colors and fonts from the Wolfram|Alpha defaults to Jeremy’s design. I made a function for this:

Here is the skyPod using that (as it appears today):

The other pods were variations on these and can be downloaded at the bottom of this post. Happy with this, I sent the code off to Jeremy with a rough Grid structure to put them all together and went home.

Jeremy works in a different time zone and so had final formatted versions ready for me when I came in the next day. But he obviously thinks differently from me, as he took my symbolic graphics expressions, turned them into bitmap images, and used Mathematica‘s image-processing commands to size them and assemble them into a Photoshop-generated background image (this is where the ImageCrop I mentioned earlier came from). This is not how I would have done it, but there was no time to argue about programming style!

Now it was time to address the first real problem. All these web queries (over a UK ISP) meant that it took sometimes over 20 seconds to get all the components of the final image. Far too long to keep the Prime Minister waiting. So I split the assembly into three parts: pods that don’t change much (such as the planet locations), pods that change sometimes (such as the star chart, which changes about once per minute), and pods that change all the time (such as share prices). I also created an error-resistant version of ImageCompose that wouldn’t fail if one of the images turned out not to be an image.

Here is the modified version of his code for the slow refresh (most of the code is position and size information):

And then the fast refresh elements added in:

And finally, the parts that absolutely had to be real-time:

Having done all this, I formatted it as a package to be loaded with Needs["Plaque`"].

You may have noticed that we faked Cameron’s age. Wolfram|Alpha does compute that data, but that idea was added to the plaque at the very last moment, so there was no time to think about computing it.

The idea of splitting the code was to run the low-refresh parts only every 60 seconds and the medium-refresh parts every 10 seconds and write the latest version to disk. I did that by using CreateScheduledTask. And to avoid the risk of a scheduled task causing the kernel to run slowly when it was called on, I put that into a second compute kernel using ParallelEvaluate.

That left my control kernel free to generate the final version and write that to disk every two seconds. It also maintained an archive, so I could retrieve the actual displayed image later.

The use of RenameFile was to reduce the chance that we tried to access the latest image while it was being written. Renaming is much faster than writing.

So now, thanks to this chain of web service calls to Wolfram|Alpha, symbolic transformation, image processing, and scheduled tasks, the plaque image is rewritten to disk every two seconds, with no part of it more than 60 seconds old.

The rest was done outside of Mathematica, as we had a Flash video that we wanted to play, and Mathematica can’t embed Flash. In the end we dropped almost all of the video and could have used a CDF for the button, but the sequence was built by then. The iPad was linked by a horrible hack of remote desktoping to a PC that was in, turn, screen sharing another PC that was driving the display. An HTML button on the final machine called the Flash script, which played the movie and loaded the most recently generated Mathematica image to display when the movie finished.

And here was the moment of truth: I was standing behind the photographer and holding my breath, hoping I had considered and trapped all possible failures:

Download this post with expanded code as a Computable Document Format (CDF) file.