We’ve Come a Long Way in 30 Years (But You Haven’t Seen Anything Yet!)
Technology for the Long Term
On June 23 we celebrate the 30th anniversary of the launch of Mathematica. Most software from 30 years ago is now long gone. But not Mathematica. In fact, it feels in many ways like even after 30 years, we’re really just getting started. Our mission has always been a big one: to make the world as computable as possible, and to add a layer of computational intelligence to everything.
Our first big application area was math (hence the name “Mathematica”). And we’ve kept pushing the frontiers of what’s possible with math. But over the past 30 years, we’ve been able to build on the framework that we defined in Mathematica 1.0 to create the whole edifice of computational capabilities that we now call the Wolfram Language—and that corresponds to Mathematica as it is today.
From when I first began to design Mathematica, my goal was to create a system that would stand the test of time, and would provide the foundation to fill out my vision for the future of computation. It’s exciting to see how well it’s all worked out. My original core concepts of language design continue to infuse everything we do. And over the years we’ve been able to just keep building and building on what’s already there, to create a taller and taller tower of carefully integrated capabilities.
It’s fun today to launch Mathematica 1.0 on an old computer, and compare it with today:
Yes, even in Version 1, there’s a recognizable Wolfram Notebook to be seen. But what about the Mathematica code (or, as we would call it today, Wolfram Language code)? Well, the code that ran in 1988 just runs today, exactly the same! And, actually, I routinely take code I wrote at any time over the past 30 years and just run it.
Of course, it’s taken a lot of long-term discipline in language design to make this work. And without the strength and clarity of the original design it would never have been possible. But it’s nice to see that all that daily effort I’ve put into leadership and consistent language design has paid off so well in long-term stability over the course of 30 years.
It’s Grown So Much
Back in 1988, Mathematica was a big step forward in high-level computing, and people were amazed at how much it could do. But it’s absolutely nothing compared to what Mathematica and the Wolfram Language can do today. And as one way to see this, here’s how the different major areas of functionality have “lit up” between 1988 and today:
There were 551 built-in functions in 1988; there are now more than 5100. And the expectations for each function have vastly increased too. The concept of “superfunctions” that automate a swath of algorithmic capability already existed in 1988—but their capabilities pale in comparison to our modern superfunctions.
Back in 1988 the core ideas of symbolic expressions and symbolic programming were already there, working essentially as they do today. And there were also all sorts of functions related to mathematical computation, as well as to things like basic visualization. But in subsequent years we were able to conquer area after area.
Partly it’s been the growth of raw computer power that’s made new areas possible. And partly it’s been our ability to understand what could conceivably be done. But the most important thing has been that—through the integrated design of our system—we’ve been able to progressively build on what we’ve already done to reach one new area after another, at an accelerating pace. (Here’s a plot of function count by version.)
I recently found a to-do list I wrote in 1991—and I’m happy to say that now, in 2018, essentially everything on it has been successfully completed. But in many cases it took building a whole tower of capabilities—over a large number of years—to be able to achieve what I wanted.
From the very beginning—and even from projects of mine that preceded Mathematica—I had the goal of building as much knowledge as possible into the system. At the beginning the knowledge was mostly algorithmic, and formal. But as soon we could routinely expect network connectivity to central servers, we started building in earnest what’s now our immense knowledgebase of computable data about the real world.
Back in 1988, I could document pretty much everything about Mathematica in the 750-page book I wrote. Today if we were to print out the online documentation it would take perhaps 36,000 pages. The core concepts of the system remain as simple and clear as they ever were, though—so it’s still perfectly possible to capture them even in a small book.
How the World Has Changed
Thirty years is basically half the complete history of modern digital computing. And it’s remarkable—and very satisfying—that Mathematica and the Wolfram Language have had the strength not only to persist, but to retain their whole form and structure, across all that time.
Thirty years ago Mathematica (all 2.2 megabytes of it) came in boxes available at “neighborhood software stores”, and was distributed on collections of floppy disks (or, for larger computers, on various kinds of magnetic tapes). Today one just downloads it anytime (about 4 gigabytes), accessing its knowledgebase (many terabytes) online—or one just runs the whole system directly in the Wolfram Cloud, through a web browser. (In a curious footnote to history, the web was actually invented back in 1989 on a collection of NeXT computers that had been bought to run Mathematica.)
Thirty years ago there were “workstation class computers” that ran Mathematica, but were pretty much only owned by institutions. In 1988, PCs used MS-DOS, and were limited to 640K of working memory—which wasn’t enough to run Mathematica. The Mac could run Mathematica, but it was always a tight fit (“2.5 megabytes of memory required; 4 megabytes recommended”)—and in the footer of every notebook was a memory gauge that showed you how close you were to running out of memory. Oh, yes, and there were two versions of Mathematica, depending on whether or not your machine had a “numeric coprocessor” (which let it do floating-point arithmetic in hardware rather than in software).
Back in 1988, I had got my first cellphone—which was the size of a shoe. And the idea that something like Mathematica could “run on a phone” would have seemed preposterous. But here we are today with the Wolfram Cloud app on phones, and Wolfram Player running natively on iPads (and, yes, they don’t have virtual memory, so our tradition of tight memory management from back in the old days comes in very handy).
In 1988, computers that ran Mathematica were always things you plugged into a power outlet to use. And the notion of, for example, using Mathematica on a plane was basically inconceivable (well, OK, even in 1981 when I lugged my Osborne 1 computer running CP/M onto a plane, I did find one power outlet for it at the very back of a 747). It wasn’t until 1991 that I first proudly held up at a talk a Compaq laptop that was (creakily) running Mathematica off batteries—and it wasn’t routine to run Mathematica portably for perhaps another decade.
For years I used to use 1989^1989 as my test computation when I tried Mathematica on a new machine. And in 1989 I would usually be counting the seconds waiting for the computation to be finished. (1988^1988 was usually too slow to be useful back in 1988: it could take minutes to return.) Today, of course, the same computation is instantaneous. (Actually, a few years ago, I did the computation again on the first Raspberry Pi computer—and it again took several seconds. But that was a $25 computer. And now even it runs the computation very fast.)
The increase in computer speed over the years has had not only quantitative but also qualitative effects on what we’ve been able to do. Back in 1988 one basically did a computation and then looked at the result. We talked about being able to interact with a Mathematica computation in real time (and there was actually a demo on the NeXT computer that did a simple case of this even in 1989). But it basically took 18 years before computers were routinely fast enough that we could implement Manipulate and Dynamic—with “Mathematica in the loop”.
I considered graphics and visualization an important feature of Mathematica from the very beginning. Back then there were “paint” (bitmap) programs, and there were “draw” (vector) programs. We made the decision to use the then-new PostScript language to represent all our graphics output resolution-independently.
We had all sorts of computational geometry challenges (think of all those little shattered polygons), but even back in 1988 we were able to generate resolution-independent 3D graphics, and in preparing for the original launch of Mathematica we found the “most complicated 3D graphic we could easily generate”, and ended up with the original icosahedral “spikey”—which has evolved today into our rhombic hexecontahedron logo:
In a sign of a bygone software era, the original Spikey also graced the elegant, but whimsical, Mathematica startup screen on the Mac:
Back in 1988, there were command-line interfaces (like the Unix shell), and there were word processors (like WordPerfect). But it was a new idea to have “notebooks” (as we called them) that mixed text, input and output—as well as graphics, which more usually were generated in a separate window or even on a separate screen.
Even in Mathematica 1.0, many of the familiar features of today’s Wolfram Notebooks were already present: cells, cell groups, style mechanisms, and more. There was even the same doubled-cell-bracket evaluation indicator—though in those days longer rendering times meant there needed to be more “entertainment”, which Mathematica provided in the form of a bouncing-string-figure wait cursor that was computed in real time during the vertical retrace interrupt associated with refreshing the CRT display.
In what would now be standard good software architecture, Mathematica from the very beginning was always divided into two parts: a kernel doing computations, and a front end supporting the notebook interface. The two parts communicated through the MathLink protocol (still used today, but now called WSTP) that in a very modern way basically sent symbolic expressions back and forth.
Back in 1988—with computers like Macs straining to run Mathematica—it was common to run the front end on a local desktop machine, and then have a “remote kernel” on a heftier machine. Sometimes that machine would be connected through Ethernet, or rarely through the internet. More often one would use a dialup connection, and, yes, there was a whole mechanism in Version 1.0 to support modems and phone dialing.
When we first built the notebook front end, we thought of it as a fairly thin wrapper around the kernel—that we’d be able to “dash off” for the different user interfaces of different computer systems. We built the front end first for the Mac, then (partly in parallel) for the NeXT. Within a couple of years we’d built separate codebases for the then-new Microsoft Windows, and for X Windows.
But as we polished the notebook front end it became more and more sophisticated. And so it was a great relief in 1996 when we managed to create a merged codebase that ran on all platforms.
And for more than 15 years this was how things worked. But then along came the cloud, and mobile. And now, out of necessity, we again have multiple notebook front end codebases. Maybe in a few years we’ll be able to merge them again. But it’s funny how the same issues keep cycling around as the decades go by.
Unlike the front end, we designed the kernel from the beginning to be as robustly portable as possible. And over the years it’s been ported to an amazing range of computers—very often as the first serious piece of application software that a new kind of computer runs.
From the earliest days of Mathematica development, there was always a raw command-line interface to the kernel. And it’s still there today. And what’s amazing to me is how often—in some new and unfamiliar situation—it’s really nice to have that raw interface available. Back in 1988, it could even make graphics—as ASCII art—but that’s not exactly in so much demand today. But still, the raw kernel interface is what for example wolframscript uses to provide programmatic access to the Wolfram Language.
There’s much of the earlier history of computing that’s disappearing. And it’s not so easy in practice to still run Mathematica 1.0. But after going through a few early Macs, I finally found one that still seemed to run well enough. We loaded up Mathematica 1.0 from its distribution floppies, and yes, it launched! (I guess the distribution floppies were made the week before the actual release on June 23, 1988; I vaguely remember a scramble to get the final disks copied.)
Needless to say, when I wanted to livestream this, the Mac stopped working, showing only a strange zebra pattern on its screen. Whacking the side of the computer (a typical 1980s remedy) didn’t do anything. But just as I was about to give up, the machine suddenly came to life, and there I was, about to run Mathematica 1.0 again.
I tried all sorts of things, creating a fairly long notebook. But then I wondered: just how compatible is this? So I saved the notebook on a floppy, and put it in a floppy drive (yes, you can still get those) on a modern computer. At first, the modern operating system didn’t know what to do with the notebook file.
But then I added our old “.ma” file extension, and opened it. And… oh my gosh… it just worked! The latest version of the Wolfram Language successfully read the 1988 notebook file format, and rendered the live notebook (and also created a nice, modern “.nb” version):
There’s a bit of funny spacing around the graphics, reflecting the old way that graphics had to be handled back in 1988. But if one just selects the cells in the notebook, and presses Shift + Enter, up comes a completely modern version, now with color outputs too!
The Path Ahead
Before Mathematica, sophisticated technical computing was at best the purview of a small “priesthood” of technical computing experts. But as soon as Mathematica appeared on the scene, this all changed—and suddenly a typical working scientist or mathematician could realistically expect to do serious computation with their own hands (and then to save or publish the results in notebooks).
Over the past 30 years, we’ve worked very hard to open progressively more areas to immediate computation. Often there’s great technical sophistication inside. But our goal is to be able to let people translate high-level computational thinking as directly and automatically as possible into actual computations.
The result has been incredibly powerful. And it’s a source of great satisfaction to see how much has been invented and discovered with Mathematica over the years—and how many of the world’s most productive innovators use Mathematica and the Wolfram Language.
But amazingly, even after all these years, I think the greatest strengths of Mathematica and the Wolfram Language are only just now beginning to become broadly evident.
Part of it has to do with the emerging realization of how important it is to systematically and coherently build knowledge into a system. And, yes, the Wolfram Language has been unique in all these years in doing this. And what this now means is that we have a huge tower of computational intelligence that can be immediately applied to anything.
To be fair, for many of the past 30 years, Mathematica and the Wolfram Language were primarily deployed as desktop software. But particularly with the increasing sophistication of the general computing ecosystem, we’ve been able in the past 5–10 years to build out extremely strong deployment channels that have now allowed Mathematica and the Wolfram Language to be used in an increasing range of important enterprise settings.
Mathematica and the Wolfram Language have long been standards in research, education and fields like quantitative finance. But now they’re in a position to bring the tower of computational intelligence that they embody to any area where computation is used.
Since the very beginning of Mathematica, we’ve been involved with what’s now called artificial intelligence (and in recent times we’ve been leaders in supporting modern machine learning). We’ve also been very deeply involved with data in all forms, and with what’s now called data science.
But what’s becoming clearer only now is just how critical the breadth of Mathematica and the Wolfram Language is to allowing data science and artificial intelligence to achieve their potential. And of course it’s satisfying to see that all those capabilities that we’ve built over the past 30 years—and all the design coherence that we’ve worked so hard to maintain—are now so important in areas like these.
The concept of computation is surely the single most important intellectual development of the past century. And it’s been my goal with Mathematica and the Wolfram Language to provide the best possible vehicle to infuse high-level computation into every conceivable domain.
For pretty much every field X (from art to zoology) there either is now, or soon will be, a “computational X” that defines the future of the field by using the paradigm of computation. And it’s exciting to see how much the unique features of the Wolfram Language are allowing it to help drive this process, and become the “language of computational X”.
Traditional non-knowledge-based computer languages are fundamentally set up as a way to tell computers what to do—typically at a fairly low level. But one of the aspects of the Wolfram Language that’s only now beginning to be recognized is that it’s not just intended to be for telling computers what to do; it’s intended to be a true computational communication language, that provides a way of expressing computational thinking that’s meaningful both to computers and to humans.
In the past, it was basically just computers that were supposed to “read code”. But like a vast generalization of the idea of mathematical notation, the goal with the Wolfram Language is to have something that humans can readily read, and use to represent and understand computational ideas.
Combining this with the idea of notebooks brings us the notion of computational essays—which I think are destined to become a key communication tool for the future, uniquely made possible by the Wolfram Language, with its 30-year history.
Thirty years ago it was exciting to see so many scientists and mathematicians “discover computers” through Mathematica. Today it’s exciting to see so many new areas of “computational X” being opened up. But it’s also exciting to see that—with the level of automation we’ve achieved in the Wolfram Language—we’ve managed to bring sophisticated computation to the point where it’s accessible to essentially anyone. And it’s been particularly satisfying to see all sorts of kids—at middle-school level or even below—start to get fluent in the Wolfram Language and the high-level computational ideas it provides access to.
If one looks at the history of computing, it’s in many ways a story of successive layers of capability being added, and becoming ubiquitous. First came the early languages. Then operating systems. Later, around the time Mathematica came on the scene, user interfaces began to become ubiquitous. A little later came networking and then large-scale interconnected systems like the web and the cloud.
But now what the Wolfram Language provides is a new layer: a layer of computational intelligence—that makes it possible to take for granted a high level of built-in knowledge about computation and about the world, and an ability to automate its application.
Over the past 30 years many people have used Mathematica and the Wolfram Language, and many more have been exposed to their capabilities, through systems like Wolfram|Alpha built with them. But what’s possible now is to let the Wolfram Language provide a truly ubiquitous layer of computational intelligence across the computing world. It’s taken decades to build a tower of technology and capabilities that I believe are worthy of this—but now we are there, and it’s time to make this happen.
But the story of Mathematica and the Wolfram Language is not just a story of technology. It’s also a story of the remarkable community of individuals who’ve chosen to make Mathematica and the Wolfram Language part of their work and lives. And now, as we go forward to realize the potential for the Wolfram Language in the world of the future, we need this community to help explain and implement the paradigm that the Wolfram Language defines.
Needless to say, injecting new paradigms into the world is never easy. But doing so is ultimately what moves forward our civilization, and defines the trajectory of history. And today we’re at a remarkable moment in the ability to bring ubiquitous computational intelligence to the world.
But for me, as I look back at the 30 years since Mathematica was launched, I am thankful for everything that’s allowed me to single-mindedly pursue the path that’s brought us to the Mathematica and Wolfram Language of today. And I look forward to our collective effort to move forward from this point, and to contribute to what I think will ultimately be seen as a crucial element in the development of technology and our world.
Great anniversary. I have been using Mathematica for 62% of my coding life (late starter; I got Mathematica 1.1 in 1989 and I started coding in 1971 at the age of 25). It is the oldest program I have used continuously since I started. BBEdit, which just crossed 25 years, is next. Looking forward to great things in the next 30 years.
So, when does the new x.0 Version come out? It’s been a couple years since the last one…
I assume it’s coming out this summer? Do you guys have a tentative or definitive date for it yet??
I’d love to buy an upgrade for the home/hobby desktop version if/when it’s available and/or on sale (limited funds)…
Seems like every time I ask you guys are cagey and like “we don’t know, but buy a subscription.”
I’d love it if you guys would like actually publish a rough roadmap of when minor/ major releases were tentatively expected to be out. I get that things are always ‘in development’ (until they’re not, and they ship), and things are “ready when they’re ready,” ’cause you don’t want ship buggy code. But, a rough timeframe for major releases would be nice… So, folks wouldn’t have to keep “asking” about it…
Thanks for your comment! Yes, we intend to ship an integer release this year!
However, we are in development building things that have never been built before, so we unfortunately can’t provide even a tentative ship date until all new features and functions have been built and tested. We are definitely not trying to keep the release date a secret by any means. When everything has been tested and are sure that the functions are going to operate appropriately, we’ll have a better idea of a timeline for it to ship. At this point though, the best we can say is that it will be sometime this year.
Well, thanks for the somewhat update. :)
Just always feels a bit like “Surprise! Here’s a new version we’ve told you nothing about ahead of time!”
Would just be nice if there was a bit of foreshadowing / forewarning. Like “we’re working on version 12, and hope to have it done by late Q3 or early Q4, and here are some of the things we’re working on trying to build in or improve upon.”
I mean, surely, as a company, you have internal [project management] roadmaps and goal posts for getting things done by such and such a date (else projects would take 5 years, or some unknown length of time, to ship, if ever). Would just be nice if we got some hint of upcoming anticipated “major mileposts” like x.0 releases & x.n releases.
But, I get it that it’s not always 100% clear when a specific algorithm or piece of code will be ready to go.
Still, it seems like many companies (say, Intel / AMD) will publish public roadmaps of anticipated products / features that are in development, and when they’re tentatively slated for, or update if some specific feature gets pushed back to a subsequent release, etc.
Anyway, won’t beat a dead horse. Too much. :)
Good to hear that a x.0 release is coming up shortly / eventually. Even if the specific date is still, perhaps, up in the air. Would just be good to know when, in case folks want/need to budget for purchases, license upgrades, etc. ^_^
Can’t wait to see what’s new/improved in v12.0 if/when it ships. I’m sure it’ll be leaps and bounds above v9.0, which I think is my current version at home? Can’t wait to try out the new/improved Style Transfer algorithms if/when I manage to upgrade to the latest version…
Thank you for reaching out. At this time, the most accurate response we can give is that v.12 will release sometime in the fall/winter of 2018. Our development team is currently hard at work on new features for v.12 right now, (as you noted in your comment) it is impossible to say exactly when new features (and which features) are going to be completely ready to deploy.
If you would like to get an inside look at some of the new features that are being developed for the next release, I would suggest that you check out some of Stephen’s livestreams via Twitch, YouTube, and Facebook. These are truly unique events designed to give the public an inside look at what we’re working on. Each livestream is an actual internal development meeting between Stephen and the development folks spearheading the creation of new functions to be included in the next release. Further, these livestreams are interactive! Each platform includes a chat feature where viewers can submit questions and comments related to the meeting’s topic. Most of these questions and comments submitted are discussed by Stephen and the developers during the live meeting. We’ve already had instances where viewers have actually named certain new functions or provided information that has led to our team creating a new function to address the needs of users. So if you want an inside look at what is being worked on for inclusion in the next version of Mathematica, check out one of these streams. All streams are archived on each of the platforms, so you can always visit Stephen’s website (http://www.stephenwolfram.com/livestreams/) to view past development meetings.
Maybe I’ll track down some of the live streams. Sounds … interesting. ^_^
(Only a couple months left this year! Hope the new release will be interesting and full of sweet new / improved features. And, maybe a sale on “upgrades” or two would be nice, at some point. Will be neat to play with the Image Style Transfer function(s). Pretty sure I’m still on v9, so will be nice to eventually bump up to v12 functionality and all that brings… When I get around to it.)
Nice. I hear that you give free licenses to celebrate :)
We’ll go ahead and add that suggestion to our files :)
Congratulations upon 30y! I use Mma 7.0 regularly. Mma’s methodical, modular and scalable approach to “doing mathematics by computer” has shaped my approach to analog circuit design. Thank you.
I was thrilled when, in 1987, I learned that a new symbolic computation engine had been developed that would run on my 528K MacPlus. As soon as Mathematica became available, I bought a copy, started reading Stephen’s huge tome that described how to use it, prepared a presentation on Mathematica for my colleagues at work, and convinced my employer to purchase a copy. I’ve been a Mathematica enthusiast ever since.
It would be cool if you were to publish Mathematica 1.0 on the Internet Archive so anyone could try it out: https://archive.org/details/softwarelibrary_mac
So happy to have worked with Mathematica since 1992, approx. the 2.2 era. (When did we stop italicizing “Mathematica”?) Thank you for a quarter century of diversion and learning—among the things I’ve learned is that quality counts for something—and I look forward to seeing what’s next!
Congratulations to Stephen and the Mathematica crew, I started with SMP in ’86 and every time I use Mathematica I can appreciate the evolution it has gone through in these years. I naturally expect great developments in the future of Mathematica. Best wishes.
I have been using Mathematica on the Mac since the very early days, when you could actually talk to Stephen in the hall at Moscone Center. Love it! Cannot do without it. I used it TODAY as a matter of fact.
A singular vision, and distinctly singularly projected – and we see how that can be a Very Good Thing! I’m pleased, if just for that.
I was a bit delayed coming to the party. I could have sworn I’d seen Mathematica boxes and their contained real manuals and disks on other people’s desks at Whitbread back in 1984, but I suppose that can’t be possible. Used wolframalpha.com for the first time a few months ago.
Please, please don’t forget your first love: math! Mathematica is my main software for researching the mysteries of math.
Agreed. Love Mathematica! Running v9, I think? Can’t wait for v12 to come out, hopefully sometime soon? :) Really want to try the Deep Style (Style Transfer) algorithms.
I use Mathematica all the time to plumb the mysteries of mathematics. I’ve even managed to solve (of a sort, to my own satisfaction) some inquiries of my own devising (one of which I worked on, on and off, for about a decade; a musing here, a graph there, trying to figure it out, taking long breaks, and coming back to it, then putting it down again, and coming back at it fresh months or more later).
At some point, I should really write it all out and publish it somewhere, before I die. ;) Heh. I keep wanting to “solve” just a few more cases / applications. I guess I should just write little bits incrementally and publish them on viXra, or whatever…
Anyway, truly a great math / computation / graphing / visualization engine… ^_^
What happens when you enter the linked Wolfram Cloud code into Mathematica 1.0 on one of those early era computers? https://mathematica.wolframcloud.com/app/objects/13b99f2f-ba91-485e-bcd4-b5544c79873b
This is very difficult to say since some of features didn’t even exist in version 1.0. Further, we don’t have one of the old computers handy to test this out for you. What we can do though is ask some individuals who have had a hand in the evolution of Mathematica’s development over the years and see if they might be able to offer some insight.
Most likely it simply wouldn’t understand what you’re talking about, since the cloud functionality wasn’t added to Mathematica until just a few years ago. So, putting “Cloud Access” code into an early (1.0) notebook wouldn’t do much of anything, since the Cloud, let alone functions to access data from it had neither been invented nor coded into Mathematica yet, back then.
Most likely it would simply do nothing or generate an error of some kind? ;)
Could not have done my work in the last 20 years without Mathematica.
Congratulations! I can’t even imagine how it must feel to design something so robust and keep it growing and relevant for such a long time. The improvements over the last years, since I started using it at the end of highschool, have been amazing. (One of my math teachers was a contributor to the Wolfram Demonstrations Project).
Today as a researcher in academia I still use it a lot and it is always very useful for many purposes.
However, I can see that due to the problem of expensive licenses and heavy installation files (but especially due to licenses) it is losing a lot of ground to open source alternatives like Python and Jupyter notebooks.
It would be nice if at some point Wolfram decided to release the Wolfram Language for free and then just charge for the cloud services, the industry integrations and some databases in the same way that other companies do around python.
Otherwise I think it will never be a language of universal acceptance.
Hi, Santiago. Thanks for your thoughtful comment! You may be interested to see all of the services that actually are available for free: http://www.wolfram.com/open-materials/
While the full version of Mathematica isn’t available for free, the Programming Lab actually is and that basically gives a cloud-based version of Mathematica. Additionally, as I’m sure you know, Mathematica is available for free on the Raspberry Pi.
This was a very interesting presentation on the history and recent Mathematica developments and usage, and compliment included for the information that is provided in the sub-links too. I’ll add kudo’s for the company and the excellent employees who represent the software. Best regards and wishes for the future.
Thank you for the kind words, Garry!
Hi dears, Thanks a lot since from the time I used Mathematica 2 in Keele University on 1997-2001 while was doing my PhD in Appliied Mathematics. I used Mathematica on applying the asymptotics (WKB) method for solving the eigen-value problems arises in the finite elasticity theory. Apart from this interesting software i.e. Mathematica, the lengthy expressions (asymptotic expressions) may not be used. especially while we apply WKB method as a system of 3 or more equations & more than that while this method can be applied for solving a system of equations (the eigen-value problems arises from the theory of Finite Elsticity). with the best regards to all the members of the wolfram team & especially the Great person of Wolfram i.e. Stephen Wolfram
Thumbs up for the incredible job! Although, I am not an expert programmer but I found this Mathematica tool very interesting. Congratulations to the team who made this journey possible and best wishes for the future too.
I hope someone embeds Deep Learning within Mathematica to help build the repository of built-in or defined functional relationships if possible.
Have you had a chance to check out all of our machine learning capabilities? http://www.wolfram.com/featureset/machine-learning/
Congratulations to Stephen and the Mathematica crew, I started with SMP in ’86 and every time I use Mathematica I can appreciate the evolution it has gone through in these years. I naturally expect great developments in the future of Mathematica.
Congratulations upon 30y!
I have been using Mathematica for my entire life from 1992. It is the oldest program I have used continuously since I started.
I do really love Mathematica, the elegance and efficiency of its language and yes: it does make the world as computable as possible, and adds a layer of computational intelligence to everything.
Thank you Stephen Wolfram and his incredible team.