Sergey Brin was only working on open sourcing the "pure language" part of it [1].
I share the dream of an open source Mathematica. It's so rich, elegant and powerful, using it would be a no-brainer. But in its present state? Nope. I've been bitten too many times by the proprietary nature of Matlab, in which I have invested a lot of work, to repeat the mistake. More specifically and from the top of my mind, I found that proprietary means:
- I cannot run my code on my personal PC
- some people I'm collaborating with cannot use my work
- when I move to a different job, there is a good chance I cannot reuse my code
- even when my new workstation (or my colleague's PC) does have the software installed, there is a good chance the version is incompatible with my code or the license doesn't include some toolbox I'm using
- some work I want to make freely available is of no use to someone who cannot afford the software
Notably absent from the list is the notion that I cannot check what is happening in the proprietary code. That is because the Matlab functions I needed to check were written in Matlab and perfectly readable. I'm sure the issue is real though, and I would be concerned if a new kind of science developed that produced results through opaque processes in closed source proprietary software.
Because most of Mathematica is written in Mathematica, you can actually introspect large parts of the codebase (by using DownValues). Try e.g.:
DownValues[GraphPlot]
Sometimes various symbols are 'ReadProtected', which prevents you from seeing their internal definition. But guess what? You can just Unprotect them and remove that attribute. And even introduce new definitions to monkey-patch the language!
Only a smallish subset of the language is written in C (for speed).
Edit: It's also kinda fun to use
Names["*`*"]
to see all the defined symbols in a fresh kernel -- there's a lot of hidden stuff there. Try
Names["Internal`*"]
Names["Developer`*"]
to see some stuff the developers kept to themselves :)
Interesting! Most things I tried cannot be introspected though (e.g. DSolve, LaplaceTransform) and it's of course a far cry from a commented source file or notebook. Still, more than I thought was possible with Mathematica.
The basic language is the easy bit. I've gotten the itch and written a sort-of-mathematica interpreter twice now.
Each time I've gotten to the point where I can do basic derivatives/integrals/polynomials/etc and realized the real power is in the huge library (and brain trust behind that library) available to you.
It really is quite enlightening to come back to other languages. It feels like you're going back to tin can and string communications.
I am incredibly excited about the improvements for operations research markov chains and queueing, as well as timeseries. These will simplify my code hugely, better yet speed up work.
That's what Google's Brin was working on when he interned there.