Brief history of the emergence of Mathematica

Translation of Stephen Wolfram’s post " There Was a Time before Mathematica ... ".

Many thanks to Kirill Guzenko KirillGuzenko for help with the translation.

---

A few weeks later [post was written June 6, 2013 - approx. Ed.] will be the twenty-fifth anniversary: ​​June 23, 1988 - the day when Mathematica was released.



Late at night, we still wrote floppies and packed them. However, already at noon on June 23, I was at a conference center in Santa Clara, for the first time showing Mathematica to the public:





')

Yes, this was exactly the boot screen, and yes, Mathematica 1.0 worked on Macs and various workstations on Unix; Ps then lacked power.



Many were impressed by what Mathematica can do. And there were very pleasant speeches about Mathematica 's prospects from various computer industry leaders, including Steve Jobs (he was at NeXT at the time), who was very kind to come, even though he had not appeared in public for some time . And someone at this event was far-sighted enough to ask all speakers to sign the book about Mathematica , which just went on sale that day in bookstores across the country:







So much has happened to Mathematica in the quarter century since then. What started with Mathematica 1.0 has turned into an extensive system, into today's Mathematica . And so, I look at the anniversary album in honor of the 25th anniversary , and I take pride from the realization of what Mathematica contributed to research, inventions, education, science:







However, perhaps the most remarkable for me is how the fundamental principles on which I built Mathematica stood the test of time. And the way the main ideas and the language itself, which were in Mathematica 1.0, are preserved today (and yes, most of the Mathematica 1.0 code still works and remains untouched).



OK, but where did Mathematica come from? How did she become what she is? This is a very long story, really. And closely intertwined with my life . However, when I try to look into the future, I am interested in understanding how and in what ways everything changed in the past.



Perhaps the first vague glimpse pointing somewhere in the direction of Mathematica came to me when I was about six — it came to the realization that I could somehow automate these tedious addition examples, creating something like a slide rule for addition, composed of two others. I have never liked math calculations and have never been good at them. However, at the age of ten I became interested in physics, and if you really want to study it, be kind enough to study mathematics.



The first electronic calculators began to come into use when I was 12, and they fascinated me with my head. And at about the same time, I began to use my first computer - a gizmo the size of a large table, in which the memory was 8 kilosylists, 18 bits each, programmed for the most part in assembler using paper punched tape. I tried to adapt it in some way to the solution of physical problems, but without a special result. And now, I am already 16, I published several articles on physics, graduated from high school and worked in the British government laboratory. “Real” theoretical physicists practically did not use computers at that time. And I used. That HP desktop calculator (with a plotter!), Then IBM mainframe in Fortran.



Basically, I just did the calculations. However, what I wanted to do in physics, mated with the most diverse sections of algebra. And not only with algebra. Much with what. Expressions from Feynman diagrams with hundreds or thousands of elements, all of which must be represented exactly if we want to get the correct answer.



And I began to ponder what can be done about it. I imagined how all my life I would be chasing minuses and multipliers in the equations. And then I began to think about how you can use a computer. And someone told me that there are other people with similar ideas. There were three programs that I was able to learn about, and as it turned out, they all got their start after one conversation at CERN that happened in 1962: these are Reduce (written in LISP), Ashmedai (written in FORTRAN) and SCHOONSCHIP ( written in assembler 6000 CDC).



The programs were specialized, and it was unclear how many people, in addition to the authors themselves, seriously used these programs. They were very clumsy: as a rule, you “fed” a whole deck of punched cards to them, and after a while received the result, or, much more expectedly, some mysterious error message. However, I managed to start using them in problems that I encountered in physics.



And then, in the summer of 1977, I discovered the ARPANET - what has now grown into the Internet. Then there were only 256 hosts on the network. And so, @O 236 got an open computer at the Massachusetts Institute of Technology, which worked with the program Macsyma , and it was possible to carry out algebraic calculations in it interactively. I was amazed at how few people used it. But it was not long before those times when I began to spend most of the time on it. Basically, I worked with the machine at random - having done something, watched what would happen, came back, tried something again, etc. And usually did such strange things as listing various algebraic forms of the integral, purely experimentally getting, which is differentiated correctly.



My articles on physics began to include a wide variety of insane formulas. And without thinking about the fact that I could use a computer for this, people seemed to be some kind of a calculator skilled in algebra. My ambitions grew with the amount of time I spent on Macsyma. After a while, I suppose I began to use it more than anyone else in the world. But somewhere in 1979, I reached her ceiling.



Then it was November 1979. I was 20 and I just got a PhD in physics. I spent several weeks at CERN, planning my future in physics (as I thought then). And then I understood something: in order to be productive in physics, I need something more than Macsyma. And after a while I decided that the only way to get what I want is to do it myself.



And I began to implement what later became known as SMP (Symbolic Manipulation Program, a program for symbolic operations). I had extensive knowledge of the programming languages ​​of the time, both in procedural ALGOL-like and LISP and APL. And when I sketched an approximate SMP view, I got something very similar to what I saw in these languages. However, as I understood what SMP should be, I began to try to invent everything myself.



I guess I had some very interesting ideas. And, in fact, in some of the ideas from the project documentation, a very crude SMP can be traced to the motives of the upcoming Mathematica :







Looking through the SMP documentation now, I understand that it was a very impressive system, especially considering that I was only 20 years old when I began to design it. Of course, not all ideas in SMP were good. And, as a specialist in the field of design languages ​​with great experience, I can not fail to mention some of my "favorite" mistakes, which are presented at the end of this post.



Even in its early versions, SMP was a big system. But for some reason I did not find anything complicated in it. I just wanted to move on and implement it. I wanted to make sure that I did everything as well as possible. I remember the thought occurred to me: “in fact, I am not familiar with computer science; I'd rather learn it. ” Then he went to the store and bought from them all the books that had to do with it - about half the cabinet. And he began to read them one by one.



Then I worked at Caltech. And I invited everyone who could find in the world, who would work on similar systems, to give a speech. I gathered a small working group at Caltech, which for some time included Richard Feynman . And I started recruiting people from all over the campus to work on the “SMP Project”.



At the beginning, an important decision had to be made on what to write SMP. Macsyma was written in LISP, and many said that only on it and you can write. But a young postgraduate physicist named Rob Pike convinced me that C is the language of the future, that this is the right choice (Rob did a lot of things afterwards, including the creation of the Go language). And so, in early 1980, the first lines of C code for SMP were written.



The group working on the SMP had a very interesting composition. The first of those whom I invited to the group - Chris Cole - then worked as IBM and became an ardent follower of APL, after which he founded a fairly successful company called Peregrine Systems. There were students, each of whom had some of their skills, a professor who was very enthusiastic about programming, in collaboration with which I wrote several articles on physics. Of course, there were cases. There was one guy who wrote a very efficient code, moreover in one line; he used colorful names for functions, moreover so that their combination would be read like some kind of joke. Or, say, there was a brilliant bachelor's student who worked so hard on a project that he was far behind in studies; He promised not to touch the computer, but he was soon discovered to have dictated the code to his friend.



I myself wrote a lot of code for SMP (about 1000 lines every day). I came up with her design. And I wrote most of the documentation. I have never managed a large project before. However, for some reason, this has never been very difficult for me. And so, in June 1981, the first version of SMP appeared, and it was very similar to Mathematica:







For that time, SMP was a very large software system (even though the executable file weighed only about a megabyte).

Initially the system was intended for mathematical calculations. However, along the way, I realized that in order for everything to work as it should, I need to create a full-fledged, much more general symbolic language. I suppose I looked at this problem as a physicist, but instead of searching for elementary particles, I tried to find the elementary components of the calculations. For myself, I developed this approach: always try to realize as many features as possible with the minimum number of primitives. I used to solve puzzles for weeks - how to implement this or that functionality, but as a result I was able to formulate a design, which I then implemented.



I realized that everything can have a symbolic representation. Although character-indexed lists in SMP did not allow the introduction of "expression headers", which are very clearly implemented in Mathematica. And, undoubtedly, there were some oddities in the internal implementation of symbolic expressions, one of which is storing all numbers in a floating-point format (Tini Veltman, author of SCHOONSCHIP, and after that Nobel Prize in Physics, told me that storing a number in the format with floating point was one of the best solutions ever made, because FPU is much faster in arithmetic than ALU ).



Before SMP, I wrote a lot of code for systems like Macsyma, and I realized that all I was trying to do was to tell the system: “I have an expression that looks like this, and I want to bring it here to this form. Thus, in the development of SMP, the use of transformation rules for families of symbolic expressions represented by patterns has become one of the central ideas. The implementation, of course, was not as clean as in Mathematica, and there were not very good ideas in it. However, there were already many key elements.



In the end, the content of the documentation from the SMP of the first version of 1981 was fairly modern:







Yes, the graphical output is given a small section - as well as memory management. And there are such fascinating sections as “dead ends in the program” (i.e., system hang), as well as “creating statistical expressions” (i.e. creating random expressions). However, there is already a "parallel processing", along with "building programs" (i.e. code generation). SMP could even generate a C code, compile it, and, which is quite scary, dynamically link it to a running SMP executable file. And there were many mathematical functions and mathematical operations, although significantly less than in Mathematica.



Oh well. Earned SMP 1.0. And what to do with it? It was obvious that for many people the system would be useful. It ran on fairly large computers — on so-called “mini-computers,” like the VAX, which was several large refrigerators in size, and cost a few hundred thousand dollars. However, I knew that there were many research and design organizations that had similar machines.



Then I did not know anything about companies and business. But I understood that the work of people on SMP should be paid, and a very obvious way to get money was to sell copies of SMP. My first thought was to go to an organization that they would call the “technology exchange center” at the California Institute of Technology and find out if they can help us with something. At that time, the office essentially consisted of one pleasant elderly gentleman. But after several attempts, it became clear that he didn’t really know what to do. I asked him about how this could be; I thought that such things should happen all the time in Caltech. “Well,” he said, “mostly people from the faculty just go away and start their own companies themselves, so we don’t get involved in the process.” “Oh,” I said, “so can I, too?” And, scrolling through the university’s charter, he said: “software can be patented, the university does not claim copyright, so yes, you can.”



And so I did, deciding to establish my company. But it was not so easy. Because some time later, the university administration suddenly decided that everything was not OK. There were very strange and unworthy moments (“take me to a share, and I will unsubscribe from this”, etc.). Richard Feynman and Murray Gell-Mann stood up on my behalf. The university president did not seem to know what to do. And for some time everything stalled. But in the end we agreed that the university would grant licenses regardless of their rights, even if they had to change something in their software documents.



As a result, there was one snag in the form of the then rector of the university. He said that such a license creates a conflict of interest between the university and the company, if I work at the university and own part of the company. “Well,” I said, “this is not a problem, I am leaving the university.” It seemed like a big surprise. But I left the university and went to the Institute for Advanced Study in Princeton, where, as the then director noted, they gave the computer when John von Neumann died, so that they could not worry too much about intellectual property.



For years, I reflected on what was really happening in Caltech. And it so happened that just a couple of weeks ago I decided to visit Caltech again (to receive the award of an “outstanding graduate”). While dining at the faculty canteen, I found that at the next table, none other than the former rector of Caltech, who was almost 95, was sitting. I was impressed by his deep response to what he called “the Wolfram Affair” (was he warned?) . As a result, our conversation clarified a lot.



Honestly, everything turned out to be even stranger than I could imagine. The story began in a sense in the 1930s, when Arnold Beckman was in Caltech, invented a pH meter, and then left the university, founding Beckman Instruments. By 1981, Beckman was the main sponsor of Caltech and the chairman of his board of trustees. Meanwhile, the chairman of his biological faculty (Lee Good) invented a genomic sequencer. He said that many times he tried to interest Beckman Instruments, but to no avail, and therefore founded his own company (Applied Biosystems), which has become very successful. At some point, as I was told, Arnold Beckman was upset and told the administration that they should “stop leaving the IP from the campus” [IP (intellectual property) - intellectual property - approx. Ed.]. And it so happened that this coincided with the time of the appearance of my SMP project. And the then rector said that he was obliged to do this (he was also a chemist, whom Feynman and Gell-Mann, as physicists, called "near physics").



But, despite all this mess, still there was a company that I called Computer Mathematics Corporation. At that time, I still presented myself as a young scientist and did not think that I would manage the company. So I brought the CEO, who was about two times older than me. And at the behest of the director and some venture capitalists, the company decided to merge with the senior manager, who, they thought, was supposed to succeed in R & D in the field of artificial intelligence.



Meanwhile, SMP advanced under the slogan "computer math":







There were terrible blunders. CEO: "Let's build a workstation to run SMP"; I: "No, we are a software company, and I saw the Stanford University Network (SUN) system, which is obviously the best thing we could do." And then there were similar unfounded statements from advertisers:







And I soon realized that all this is wrong. SMP turns out to be some kind of cash cow, and although the CEO was not particularly good at making money, he was very good at attracting them - after going through a number of successful investment turns, until he finally came to a mediocre IPO many years later.



Then for me personally there were tremendous times - I was directly involved in science, discovered things that later laid the foundations for a new type of science (A New Kind of Science) . And in fact, SMP turned out to be a base for what I eventually did. Because my principle of searching for computational primitives for SMP brought me to the idea of ​​searching for computational primitives in nature and creating a new science from studying the results of actions of these primitives.



You might ask what happened to SMP. It was still sold — until Mathematica came out. Not a single line of its code was used for Mathematica . But sometimes I ran it only to see how it looks next to it. Over time, it became harder and harder to find a machine that would run SMP. And about 15 years ago, our last computer, capable of running it, went into retirement.



Well, I thought, I always had my own copy of the SMP sources, which I had not looked at for many years. So why not recompile them on some modern system? But then I remembered my “brilliant” idea that we should keep the source code in encrypted form. But what key did we use? I asked everyone who could know him. But no one remembered him.



Many years have passed, and I really wanted to see SMP in action again. So this is the problem. Here is the C source code, encrypted in the same way as the SMP source. In fact, this is the source code of the program that encrypted it - the circa-1981 version of the Unix crypt utility, modified in a tricky way by changing a number of parameters and the like. Will anyone be able to crack the cipher, finally releasing the SMP from such a long imprisonment? This is what the Wolfram says | Alpha Pro , if we just load this file unchanged:







But back to the main story. I stopped working on SMP in 1983, doing parallel to basic science, software projects, and my (very instructive) “hobby” in technology development and strategic consulting. Little by little, I used SMP, but then I ended up writing in C, as a rule, gluing together algorithms, graphics and interfaces.



In the field of science, things were going well for me, and there was still a lot to do. However, instead of doing everything only through my own efforts, I decided to involve other people for this. And as one of the steps I decided to establish a research institute and analyzed what various universities are ready to offer. As a result, the University of Illinois was chosen, and in August 1986 I went there to establish a center for the study of complex systems.



However, by this time I had already begun to worry that my scheme for involving other people was not so good. And in the first few weeks in Illinois, my plan B matured in my head: to create the best toolkit I can, the best environment for my work, which I can do, and achieve maximum effectiveness in science on my own. And since I was closely connected with the computer industry, I knew that a variety of powerful software systems would work on a huge number of personal computers that would soon appear. And I understood that if I did something good, it could be successfully implemented in an emerging market that would support an interesting company and infrastructure.



And so, at the end of August 1986, I decided to try to develop my own computing system, which could carry out any calculations that I would like to implement and that could come to my mind.



And, of course, the result was Mathematica.



SMP and my experience with other software taught me a lot of what to do and what not to do. It was nice to know that you can start everything from scratch, trying to do everything as it should, without any restrictions. In the SMP center was algebra. But with the help of Mathematica, I wanted to cover many other areas, be it numerical calculations, graphics, programming, interface creation, and so on. I thought a lot about the foundations of the system, thinking, for example, about whether such things as the cellular automata I have studied have something to do with this. But I still focused on the basic principle developed for SMP. Symbolic expressions and transformations for them are considered as the main representation for calculations.



If this were not implemented in SMP, I would make a lot of mistakes. However, SMP taught me a lot by showing what is important and what is not, what the main problems are. Looking through my archives now, I see the painstaking process of solving puzzles from the problems I encountered when developing SMP. And step by step the decision came.



In the meantime, as in the case of SMP, I put together a team and began the direct implementation of Mathematica. I created the company again, and this time I acted as the general director. Every day I wrote a lot of code (and, which is a little sad, only a small part of this code works now in Mathematica , especially in the template matching system and calculator). However, the main focus was on design. And, just like with SMP, I wrote the documentation and developed the design. I thought that if I couldn’t explain something clearly enough in the documentation, then no one would understand it, and probably this something was created incorrectly. And as soon as something turned out to be in the documentation, we knew both what needed to be implemented and why we were doing it.



The first Mathematica code snippets were written in October 1986. And by mid-1987, Mathematica begins to be implemented. I decided that the documentation should be published as a book, and hundreds of pages had already been written. And I figured that Mathematica 1.0 will be ready by April 1988.



My initial plan for our company was to focus on research and development, and the distribution of Mathematica was intended primarily through computer manufacturers. Steve Jobs first took Mathematica "on board", which was supposed to be delivered to all, not yet released NeXT computers. Then came a deal with Sun, Silicon Graphics, IBM and a number of other companies. We started sending beta versions of Mathematica. . And let it be long before the advent of the world wide web, knowledge about the existence of our system began to spread. Some of the media have also connected (I still love this ice cream):







- 1988 23 Mathematica ( Wolfram|Alpha , , ). . . , The Mathematica Book . , , , . , , 23 :







, 23 , , Mathematica .







25 . , Mathematica 1.0, , , . « » Mathematica , . Mathematica , , Wolfram|Alpha . 25 Mathematica .

---

: SMP

What was SMP? Here are some examples of SMP programs that I wrote for SMP documentation :





















At some points they are very similar to the programs in Mathematica , along with the [...] notation for functions, {...} for lists and -> for replacement rules . But they don’t have the readability that Mathematica has , and the SMP programs look much less clear.



One of the most obvious problems is that the code in the SMP is filled with the $ and % characters, which are respectively prefixes of patterns and variables. In SMP, I have not yet implemented the idea, which appeared in Mathematica , about separating patterns (for example, _ ) from their names (for example, x ). And I thought it was important to emphasize which of the variables are local, but I didn’t have an idea about highlighting them with color.



In SMP, I have already implemented the (very useful) idea of ​​distinguishing between direct ( = ) and deferred ( : = ) assignment. However, being similar to Algol-like languages, I implemented them then not very clearly - : and :: . (For the replacement rules, form -> was exactly the form that was then implemented in Mathematica, and form --> was similar to the modern one :> . The S[...] design was similar to the modern /. )



In SMP, as well as in Mathematica , the built-in functions were written with a capital letter (at the time it was something new - the division into upper and lower registers on the computer). But while in Mathematica , as a rule, ordinary English words are used to designate functions, SMP uses short and often incomprehensible abbreviations. When I was working on SMP, I was influenced by Unix design and used the short names it uses. And everything would be fine if there were only a few functions in SMP. But with hundreds of functions whose names are similar to something like Ps , Mei and Uspb , in the end, the readability of the code is very difficult. Of course, the fact that many users do not know how to type quickly plays a role here, so this was another vote in favor of short function names.







It's very interesting to read the SMP documentation these days, SMP had a lot of good ideas that were later transferred to Mathematica . But there were bad ideas, which, fortunately, remained in history. One of these ideas, which has as bad a name as its essence is “chameleon characters”, which change their name when they are used (it was an attempt to transfer such a thing as dummy variables, something like a more automated version of the Module in Mathematica ).



There were significantly more subtle errors. As, for example, excessive zeal in the generalization of systems. As in Mathematica , in the SMP lists are designated as: {a,b,c} . Functions had the following designation: f[x] . And in my quest to achieve the highest possible unification, I decided to try to combine the concepts of lists and functions.



Let's say we have a list v={a,b,c} (in SMP, the assignment was denoted as : so that v:{a,b,c} would be written like this v:{a,b,c} ). Then, for example, v[2] in SMP would extract the second list item. But this designation looks the same as if we had requested the value of the function v with argument 2. And this gave me the idea that it is possible to generalize the lists so that they have not only an integer number of elements, but any express in symbolic form.



In SMP, template expressions ( x_ in Mathematica ) were written like this: $x . That is, when defining the function f[$x]:$x^2 you can imagine that this is simply the definition of f as a list with symbolic indexing: {[$x]: $x^2} . If you need to know how the function was defined, then simply enter its name - f , for example. And the resulting value would be a symbolically indexed list, which would be a definition.



A regular list of a vector type can be viewed as something like {[1]:a, [2]:b, [3]:c} . And you could shuffle the character indices: {[1]: 1, [$x]:$xf[$x-1]} . There was also a certain unification in numbering for generalized symbolic expressions. And everything seems to be good. And in order to describe my single concept of functions and lists, I called f in f[x] projection, and x filter.



But gradually this concept began to diverge at the seams. It turned out all sorts of strangeness when introducing definitions like v[2]:b, v[3]:c . Then for v , according to the SMP principles, there will be the values ​​of {[3]:c, [2]:b} . But what if you make the definition of v[1]:a ? In this case, v suddenly changes its order to {a, b, c} .



And everything became even stranger when using functions from several arguments. It would be great if one could define a matrix with m:{{a,b},{c,d}} , then m[1] would be {a,b} , and m[1,1] or m[1][1] will be a . But what if you need a function with multiple arguments? Will f[x, y] the same as f[x][y] ? Well, sometimes something like that was needed, and sometimes not. So I had to come up with a property (“attributes” in Mathematica ), which I called Tier , which indicated for each function how it should work (today many probably heard about currying , but then these differences did not seem obvious at all.)



Symbolic indexed lists in SMP had some elegant and powerful properties. But as a result, when the whole system was built, a lot of oddities came to light. And therefore, when I developed Mathematica , I decided not to use them. Over the years, I kept thinking about them. And it so happened that now, more than 30 years after SMP, I am working on some very interesting new functionality in Mathematica, which is closely related to symbolically indexed lists [in the 10th version of the system, associations appeared - Association - approx. Ed.].



Working on an SMP gave me invaluable experience: I saw what really worked and what didn't. And one of the most memorable moments for me was this one. As in Mathematica , the SMP had pure functions . But, unlike Mathematica , they were not indicated using the & symbol. And this meant that a special object, called a “mark” (written as ` , a typewritten reverse apostrophe) was required to indicate when a pure function should produce some symbolic, constant value. Well, five years after the release of the SMP, I looked through one of the training manuals. And the phrase “reverse apostrophes - the SMP mystery” caught my eye. And then I realized: this is how the errors look in the design of the language.



SMP in many ways a radical system is something like an extreme experiment in the development of a programming language. There was only minimal support for familiar designs. And instead, everything revolved around the idea of ​​using the rules for converting symbolic expressions. In some ways, I think SMP is too far removed from established traditions. After all, a programming language must connect human concepts about calculations with real calculations that a computer can perform. And no matter how powerful a language may be, there is little that can be done with it if people do not have enough context to understand it. That is why in Mathematica I have always tried to give things a recognizable look, where it is possible, and to introduce something unfamiliar only in really necessary cases, for something fundamentally new.



One of the important points in the design of the system is to know what will be important in it. In SMP, we spent a lot of effort on the so-called "semantic patterns". Let's say we have the following definition: f[$x+$y, $x, $y] := {$x, $y} . It is quite clear that f[a+b, a, b] will correspond to it. But what about f[7, 3, 4] ? In SMP, the template will be satisfied, although 7 is not the form of the $x+$y structure. It took a lot of effort to implement this. And in simple examples, everything looked great. But, in the end, this is not required very often, and if required, they try to avoid this, because such constructions greatly worsen the readability of the program, it becomes difficult to understand what it does.



There was something similar with recursion control. I thought that these constructions should be avoided f[$x] : $xf[$x-1] (without setting f[1] ), because they have an infinite loop, trying to calculate f[-1] , f[-2] and so on, until, at the end of the day, at some point the multiplication by 0 does not occur. So why not just give zero? Well, the default SMP was zero. Because instead of going all the way through the calculation of each branch of the recursion tree, the SMP periodically stopped and tried to simplify all uncompleted branches. It was smart and elegant. However, when someone tried to set such behavior, everything became too difficult to understand, and in the end no one used it.



And then there was a user-defined syntax. He allowed, for example, to set " U " (say, for " union ") as an infix operator. And everything worked fine until someone entered a function named "u". Or until someone becomes a prisoner of his own syntax.



SMP taught me a lot. And Mathematica would not be so good if it were not preceded by an SMP. And now, thinking now about errors in SMP, I am pleased with the fact that, perhaps, all these errors are in the past. After SMP and 25 years of working on Mathematica design, most of them fall into the category of simple tasks.



It's funny how often not the best ideas appeared in SMP. And, in fact, I am very curious, with my current views on design, that I would have experienced if I had launched SMP. And this is one of the reasons why I want to release her from prison and make her work again. I hope one of you can help me with this.