What Should We Call the Language of Mathematica?

At the core of Mathematica is a language. A very powerful symbolic language. Built up with great care over a quarter of a century—and now incorporating a huge swath of knowledge and computation.

Millions and millions of lines of code have been written in this language, for all sorts of purposes. And today—particularly with new large-scale deployment options made possible through the web and the cloud—the language is poised to expand dramatically in usage.

But there’s a problem. And it’s a problem that—embarrassingly enough—I’ve been thinking about for more than 20 years. The problem is: what should the language be called?

Usually on this blog when I discuss our activities as a company, I talk about progress we’ve made, or problems we’ve solved. But today I’m going to make an exception, and talk instead about a problem we haven’t solved, but need to solve.

You might say, “How hard can it be to come up with one name?” In my experience, some names are easy to come up with. But others are really really hard. And this is an example of a really really hard one. (And perhaps the very length of this post communicates some of that difficulty…)

Let’s start by talking a little about names in general. There are names like, say, “quark”, that are in effect just random words. And that have to get all their meaning “externally”, by having it explicitly described. But there are others, like “website” for example, that already give a sense of their meaning just from the words or word roots they contain.

I’ve named all sorts of things in my time. Science concepts. Technologies. Products. Mathematica functions. I’ve used different approaches in different cases. In a few cases, I’ve used “random words” (and have long had a Mathematica-based generator of ones that sound good). But much more often I’ve tried to start with a familiar word or words that capture the essence of what I’m naming.

And after all, when we’re naming things related to our company, we already have a “random” base word: “wolfram”. For a while I was a bit squeamish about using it, being that it’s my last name. But in recent years it’s increasingly been the “lexical glue” that holds together the names of most of the things we’re doing.

And so, for example, we have products like Wolfram Finance Platform or Wolfram SystemModeler for professional markets that have that “random” wolfram word, but otherwise try to say more or less directly what they are and what they do.

Wolfram|Alpha is aimed at a much broader audience, and is a more complex case. Because in a short name we need to capture an almost completely new concept. We describe Wolfram|Alpha as a “computational knowledge engine”. But how do we shorten that to a name?

I spent a very long time thinking about it, and eventually decided that we couldn’t really communicate the concept in the name, and instead we should just communicate some of the sense and character of the system. And that was how we ended up with “alpha”: with “alphabet simplicity”, a connection to language, a technical character, a tentative software step, and the first, the top. And I’m happy to say the name has worked out very well.

OK. So what about the language that we’re trying to name? What should it be called?

Well, I’m pretty sure the word “language” should appear in the name, or at least be able to be tacked onto the name. Because if nothing else, what we’ve got really is quintessentially a language: a set of constructs that can be strung together to represent an infinite range of meanings.

Our language, though, works in a somewhat different way from ordinary human natural language—most importantly, because it’s completely executable: as soon as we express something in the language, that immediately gives us a specification for a unique sequence of computational actions that should be taken.

And in this respect, our language is like a typical computer language. But there is a crucial difference, both practical and philosophical. Typical computer languages (like C or Java or Python) have a small collection of simple built-in operations, and then concentrate on ways to organize those operations to build up programs. But in our language—built right into the language—is a huge amount of computation capability and knowledge.

In a typical computer language, there might be libraries that exist for different kinds of computations. But they’re not part of the language, and there’s no guarantee they fit together or can be built on. But in our language, the concept from the very beginning has been to build as much as possible in, to have a coherent structure in which as much is automated as possible. And in practice this means that our language has thousands of carefully designed functions and structures that automate a vast range of computations and deliver knowledge in immediately usable ways.

So while in some aspects of its basic mode of operation our language is similar to typical computer languages, its breadth and content is much more reminiscent of human languages—and in a sense it generalizes and deepens both concepts of language.

But OK, what should it be called? Well, I first started thinking about this outrageously long ago—actually in 1990. The software world was different then, and there were different ways we might have deployed the language back then. But despite having put quite a bit of software engineering work into it, we in the end never released it at all. And the single largest reason for that, embarrassingly enough, was that we just couldn’t come up with a name for it that we liked.

The “default name” that we used in the development process was the M Language, with M presumably short for Mathematica. But I never liked this. It seemed too much like C—a language which I’d used a lot, but whose character and capabilities were utterly different from our language. And particularly given the name “C”, M seemed to suggest a language somehow based on “math”. Yet even at that time—and to a vastly greater extent today—the language is about much much more than math. Yes, it can do math really well. But it’s broad and deep, and can do an immense range of other algorithmic and computational things—and also an increasing range of things related to built-in knowledge.

One might ask why Mathematica is named as it is. Well, that was a difficult naming process too. The original development name for Mathematica was Omega (and there are still filetype registrations for Mathematica based on that). Then there was a brief moment when it was renamed Polymath. Then Technique. And then there were a whole collection of possibilities, captured in this old list:

But finally, at the urging of Steve Jobs, we settled on a name that we had originally rejected for being too long: Mathematica. My original conception of the system—as well as the foundations we built for it—went far beyond math. But math was the first really obvious application area—which is why, when Mathematica was first released, we described it as “a system for doing mathematics by computer”.

I’ve always liked Mathematica as a name. And back in 1988 when Mathematica was launched, it introduced in many ways a new type of name for a computer system, with a certain classical stylishness. In the years since, the name Mathematica has been widely imitated (think Modelica, for example). But it’s become clear that for Mathematica itself the name “Mathematica” is in some sense much too narrow—because it gives the idea that all that Mathematica does is math.

For our language we don’t want to have the same kind of problem. We want a name that communicates the generality and breadth of the language, and is not tied to one particular application area or type of usage. We want a name that makes sense when the language is used to do tiny pieces of interactive work, or to create giant enterprise applications, and to be used by seasoned software engineers, or by casual script tweakers, or by kids getting their first introduction to programming.

My personal analytics data show that I’ve been thinking about the problem of naming our language for 23 years—with episodic bursts of activity. As I mentioned, the original internal name was the M Language. More recently the default internal name has been the Wolfram Language.

Back in the early 1990s, one of my favorite ideas was Lingua—the Latin for language (as well, unfortunately, as tongue), analogous to the Latin character of Mathematica. But Lingua just sounded too weird, and the “gwa” was unpronounceable by too many people whose native languages don’t contain that sound. There was some brief enthusiasm for Express (think “expression”, as well as “express train”), but it died quickly.

There were early suggestions from the MathGroupMathematica community, like Principia, Harmony, Unity and Tongue (in the latter case, a wag pointed out that bugs could be “slips of the tongue”). One summer intern who worked on the language in 1993 was Sergey Brin (later of Google fame); he suggested the name Thema—”the heart of mathematica” (“ma-thema-tica”). My own notes from that time record rather classical-sounding name ideas like Radix, Plurum, Practica and Programos. And in addition to thinking a lot about it myself, I asked linguists, classicists, marketers and poets—as well as a professional naming expert. But somehow every name either said too little or too much, was too “heavy” or too “light”, or for some reason or another just sounded silly. And after more than 20 years, we still don’t have a name we like.

But now, with all the new opportunities that exist for it, we just have to release the language—and to do that we have to solve the problem of its name. Which is why I’ve been thinking hard about it again.

So, what do we want to communicate about the language? First and foremost, as I explained above, it’s not like other languages. In a sense, it’s a new kind of language. It’s computational, but it’s also got intrinsic content: broad knowledge, structures and algorithms built in. It’s a language that’s highly scalable: good for programs ranging from the absolutely tiny to the huge. It’s a very general language, useful for a great many different kinds of domains. It’s a symbolic language with very clear principles, that can describe arbitrary structures as well as arbitrary data. It’s a fusion of many styles of programming, notably functional and pattern based. It’s interactive. And it prides itself on coherence of design, and tries to automate as much as possible of what it does.

At this point, we pretty much have to have “wolfram”—or at least some hint of it—in the name. But it would be nice if there was a good short name or nickname too. We want to communicate that the language is something that we as a company take responsibility for, but also that it will be very widely and often freely available—and not some kind of rare expensive thing.

All right. So an obvious first question is: how are languages typically named? Well, in Wolfram|Alpha, we have data on more than 16,000 human languages, current and former. And, for example, of the 100 with the most speakers, 13% end in -ese (think Japanese), 11% in -ic (think Arabic), 8% in -ian (think Russian), 5% in -ish (think English) and 3% in -ali (think Bengali). (If one looks at more languages, -ian becomes more common, and -an and -yi start to appear often too.) So should our language be called Wolframese, Wolframic, Wolframian, Wolframish or Wolframaic? Or perhaps Wolfese, Wolfic or Wolfish? Or Wolfian or Wolfan or Wolfatic, or the exotic Wolfari or Wolfala? Or a variant like Wolvese or Wolvic? There are some interesting words here, but to me they all sound a bit too much like obscure tribal languages.

So how are these names constructed? Some—particularly earlier ones—are abbreviations, like Fortran (“Formula Translation”) and APL (“A Programming Language”). Others are names of people (like Pascal, Ada and Haskell). Others are named for companies, like Erlang (“Ericsson language”) and Go (“Google”). And still others are named in whimsical sequences, like BCPL to B to C (“sea”) to shell to Perl (“pearl”) to Ruby—or just plain whimsically, like Python (“Monty Python”). And these naming trends just continue if one looks at less well-known languages.

There are two important points here: first, it seems like computer languages can be called pretty much anything; unlike for most human languages (which are usually derivative on place names), no special linguistic indicator seems to have emerged for computer languages. And second, the names of computer languages only rarely seem immediately to communicate the special features or aspirations of a given language. Sometimes they refer to computer-language history, but often they just seem like quite random words.

So for us, this suggests that perhaps we should just use our existing “random word”, and call our language the Wolfram Language, or WL—or conceivably in short form just Wolfram.

Or we could start from our “random word” wolfram, and go more whimsical. One possibility that has generated some enthusiasm internally is Wolf. Unfortunately wolves tend to have scary associations—but at least the name Wolf immediately suggests an obvious idea for an icon. And we even already have a possible form for it. Because when we introduced special-character fonts for Mathematica in the mid-1990s, we included a \[Wolf] character that was based on a little iconic drawing of mine. Dressing this up could give quite a striking language icon—that could even appear as a single character in a piece of text.

There are variants, like WolframCode or WolframScript—or Wolfcode or Wolfscript—but these sound either too obscure or too lightweight. Then there’s the somewhat inelegant WolframLang, or it shorter forms WolfLang and WolfLan, which sound too much like Wolfgang. Then there are names like WolframX and WolfX, but it’s not clear the “X” adds much. Same with WolframQ or WolframL. There’s also WolframPlus (Wolfram+), WolframStar (Wolfram*) or WolframDot. Or Wolfram1 (when’s 2?), WolframCore (remember core memory?) or WolframBase. There are also Greek-letter suffixes, Wolfram|Alpha-style, like Wolfram Omega or Wolfram Lambda (“wolf”, “ram” and “lamb”: too many animals!). Or one could go shorter, like the W Language, but that sounds too much like C.

Of course, if one’s into “wolf whimsical”, there are all kinds of places to go. Wolf backwards is Flow, though that hardly seems appropriate for a language so far from simple flowcharts. And then there are names like Howl and Growl which I can’t take too seriously. If one goes into wolf folklore, there are plenty of words and names—but they seem more suited to the Middle Ages than the future.

One can go classical, but the Latin word for wolf is Lupus, which is also the name of a disease. And the Greek is Lukos [λυκος], which just seems like a random word to modern ears. With different case endings, one gets “differently styled” words. But none of the alternate cases or variants of these words (like Lupum, Lupa or Lukon) are too promising either—though at least I get to use my knowledge of Latin and Greek from when I was a kid to determine that. (And English forms like Lupine are amusing, but don’t make it.)

And in the direction of whimsical, there are also words like Tungsten, the common English name for element 74, whose symbol W stands for “wolfram”, and whose most common ore is wolframite. (And no, it was not discovered by an ancestor of mine.)

How about doing something more scientific? Like searching a space of all possible names, “NKS style”. For example, one can just try adding all possible single letters to “wolfram”, giving such unpromising names as Wolframa,Wolframz and Wolframé. With two letters, one gets things like Wolframos, Wolframix and WolframUp. One can try just appending all possible short words, to get things like WolframHow, WolframWay and WolframArt. And it’s a single line of code in our unnamed language (or Mathematica) to find the distribution of, say, what follows “am” in typical English words—yielding ideas like Wolframsu, Wolframity or the truly unfortunate Wolframble.

But what about going in the other direction, and trying to find word forms that actually relate to what we’re trying to communicate about the language? A common way to make up new but suggestive forms is to go back to classical or Indo-European roots, and then try to build novel combinations or variants of these. And of course if we use an actual word form from a language, we at least know that it survived the natural selection of linguistic evolution.

There was a time in the past where one could have taken almost any Latin or Greek root, and expected it to be understood in educated company (as perhaps cyber- was when it was introduced from the Greek [κυβερνητης] for steersman or rudder). But in today’s world we pretty much have to limit ourselves to roots which are already at least somewhat familiar from existing words.

And in fact, in the relevant area of “semantic space”, “lexical space” is awfully crowded with rather common words. ”Language”, for example, is lingua (“linguistics”) or sermo (“sermon”) in Latin, and glossa [γλωσσα] (“glossary”) or phone [φωνη] (“telephone”) in Greek. “Computation” is computatio in Latin, and arithmos [αριθμος] (“arithmetic”) or logismos [λογισμος] (“logistics”) in Greek. “Knowledge” is scientia (“science”) or cognitio (“cognition”) in Latin, and episteme [επιστημη] (“epistemology”), mathesis [μαθησις] (“mathematics”) or gnosis [γνωσις] (“diagnosis”) in Greek. “Reasoning” is ratio (“rational”) in Latin, and logos [λογος] (“-ology”) in Greek. And so on.

But what can we form from these kinds of roots? I haven’t been able to find anything terribly appealing. Typically the names are either ugly, or immediately suggest a meaning that is clearly wrong (like Wolframology or Wolfgloss).

One can look at other languages, and indeed if you just type “translate word” into Wolfram|Alpha (and then press More a few times), you can see translations for as many as a few hundred languages. But typically, beyond Indo-European languages, most of the forms that appear seem random to an English speaker. (Bizarrely, for example, the standard transliteration of the word for “wolf” in Chinese is “lang”.)

So where can we go from here? One possible direction is this. We’ve been trying to find a name by modifying or supplementing the word “wolfram”, and expecting that the word “language” will just be added as a suffix. But we need to remember that what we have is really a new kind of language—so perhaps it’s the word “language” that we should be thinking of modifying.

But how? There are various prefixes—usually Greek or Latin—that get added, for example, to scientific words to indicate some kind of extension or “beyondness”: ana-, alto-, dia-, epi-, exa-, exo-, holo-, hyper-, macro-, mega-, meta-, multi-, neo-, omni-, pan-, pleni-, praeter-, poly-, proto-, super-, uber-, ultra- and so on. And from these Wolfram hyperlanguage (WHL?) is perhaps the nicest possibility—though inevitably it sounds a little “hypey”, and is perhaps too reminiscent of hypertext and hyperlinks. (Layering on the Greek and Latin there’s Hyperlingua too.)

Wolfram superlanguage, Wolfram omnilanguage and Wolfram megalanguage all sound strangely “last century”. Wolfram ultralanguage and Wolfram uberlanguage both seem to be “trying a bit too hard”, though Wolfram Ultra (without the “language” at all) is a bit better. Wolfram exolanguage pleasantly shortens to Wolfex, but means the wrong thing (think “exoplanet”). Wolfram epilanguage (or just Wolfram Epi) does better in terms of meaning (think “epistemology”), but sounds very technical.

A rather frustrating case is Wolfram metalanguage (WML). It sounds nice, and in Greek even means more or less the correct thing. But “metalanguage” has already come to have a meaning in English (a language about another language)—and it’s not the meaning we want. Wolfram Meta might be better, but has the same problem.

So, OK, if we can’t make a prefix to the word “language” work, how about just adding a word or phrase between “wolfram” and “language”? Obviously the resulting name is going to be long. But perhaps it’ll have a nice abbreviation or shortening.

One immediate idea is Wolfram Knowledge Language (WKL), but this has the problem of sounding like it might just be a knowledge representation language, not a language that actually incorporates lots of knowledge (as well as algorithms, etc.) More accurate would be Wolfram Knowledge-Based Language (Wolfram KBL), and perhaps whatever the name, “knowledge-based language” could be used as a description.

Another direction is to insert the word “programming”. There’s of course Wolfram Programming Language (WPL). But perhaps better is to start by describing the new kind of programming that our language makes possible—which one might call “hyperprogramming”, or conceivably “metaprogramming”. (“Macroprogramming” might have been nice, but it’s squashed by the old concept of “macros”.) And so conceivably one could have Wolfram Hyperprogramming Language (WolframHL, WolframHPL or WHL) or Wolfram Metaprogramming Language (WML)—or at least one can use “hyperprogramming language” or “metaprogramming language” as description.

OK, so what’s the conclusion? I suppose the most obvious metaconclusion is that getting a name for our language is hard. And the maddening thing is that once we do get a name, my whole 20-year quest will be over incredibly quickly. Perhaps the final name will be one we’ve already considered, but just weren’t thinking about correctly (that’s basically what happened with the name Mathematica). Or perhaps some flash of inspiration will lead to a new great name (which is basically what happened with Wolfram|Alpha).

What should the name be? I’m hoping to get feedback on the ideas I’ve discussed here, as well as to get new suggestions. I must say that as I was writing this post, I was sort of hoping that in the end it would be a waste, and that by explaining the problem, I would solve it myself. But that hasn’t happened. Of course, I’ll be thrilled if someone else just outright suggests a great name that we can use. But as I’ve described, there are many constraints, and what I think is more realistic is for people to suggest frameworks and concepts from which we’ll get an idea that will lead to the final name.

I’m very proud of the language we’ve built over all these years. And I want to make sure that it has a name worthy of it. But once we have a name, we will finally be ready to finish the process of bringing the language to the world—and I’ll be very excited to see all the things that makes possible.

As announced March 11, 2013: The final name we chose is The Wolfram Language.

Perhaps the way to best represent a symbolic language of your own creation is with a symbol of your own creation…much in the same vein as the musical artist Prince, who had, at one point in his career, changed his stage name to an unpronounceable symbol (later dubbed “Love Symbol #2″), which was actually a synthesis of the astrological symbols for the planets of Mars and Venus. Since no one would know how to pronounce this symbol, it might come to be called “The Language Formerly Known As Wolfram”.

If you don’t care for that idea, my back-up suggestion would be the acronym W.O.O.P.S. = WOlfram Omni-Programming System”.

I wish you best of luck with your decision and look forward with great anticipation to its unveiling and introduction to the world.

I think you should call it ‘Comu’ or perhaps ‘com-u’ which can be read as being short for computational universe as well as being the prefix/acronym for communication. The problem you have is that the tools of mathematica do not really describe a language in the Wittgensteinian sense that it does not picture a world but rather creates one from a simple set of rules. Languages in the sense of natural languages do not do this as their primary function. A language expresses and creates impressions, it informs rather than creates. the notion of the computational universe is a very powerful one of course because now, rather than asking an expert, one can ask the collective intelligence of the species (or perhaps if we want to apply the concept of the principle of computational equivalence the collective intelligence of the universe itself!) so for my money ‘comu’ has the kind of economy an simplicity that belies its universality and power

How about something along the lines of “Mapica” or perhaps “Cartica”; the idea of mapping or modeling, coupled with the idea of expression in a written or composed structure (map)? Or even “Morpha” or “Morphica”, denoting “form” or perhaps an allusion to “The Forms”?

Since the associations triggered by the name of a language add to how it is perceived by users (more so than the provenance of the word), a good question is: how does it make me feel to write my code in X, or when I hear about X the first time?

Importantly, we programmers feel uneasy when our code is brittle, cobbled-together, complicated, weak, in need of a rewrite, etc. Casting your code in Tungsten or Wolframite immediately ameliorates these feelings, and gives you ideas of toughness, robustness, clean and simple like a piece of metal, manliness, and so on. Especially when your language has lots of constructs that are not immediately well understood, or has lots of moving parts with perhaps unexpected interactions or other ways of shooting yourself in the foot, the extra dose of that feeling of stability and reliability surely helps. It is also an implied statement of vision and commitment to these qualities (or it would run the risk of turning into a joke).

Hip, quippy and cool-sounding names seem to be generally well received now and a subtle dose of “tongue-in-cheekness” would do away with the association of “dry” mathematical computing. Both Wolframite (quite funny, also reminds one of kryptonite or other fairy dust) and Tungsten are in that category. Unfortunately the latter is hard to Google and occurs in a company name (Tungsten Graphics).

Using an extraordinary name can convey immediately that the language is of a different (more powerful) class of language than, say, Python, C++ or even MATLAB. Otherwise newcomers are guaranteed to not expect anything outside their frame of reference at first glance, and are likely to dismiss the language out of ignorance. Although being too bold and unfamiliar (Alien Language from Space) would shy away people.

A great trick is also to pick a name that makes one feel terribly uninformed for not having heard of it before. The very funny Wolframese sounds a bit like a household name that has been around forever. The staple of technical computing. Of course the learning curve of the language is steep enough that no one would risk an association with a hard-to-learn language like Chinese. However, self-deprecating humor like that is also something that only the most established players in language land would be able to afford.

The sad fact about the no-brainer choice of calling it the Mathematica language (which I believe is what most people expect it to be called right now) is that from a user’s perspective it is often a Bad Idea to start a new software venture or long-term investment in a proprietary language that is tied to a relatively expensive sofware system. A name like that can bring to mind nightmares of software vendors forcing expensive upgrades down their user’s throats (not unheard of in technical computing). Even if the language may in practice be coupled to the software, giving it an identity of its own, at least in spirit, is a great advance.

Sorry to be gauche about this but I really think the language really should be called Com U because another route of communication is the worl commune (as in to share), in this sense the U in Com U is trxtspeak for you and the ‘message’ of the language takes the form of an invitation to join in. That’s it. Pitch over. I will say no more

I had a few name ideas, which may or may not have been suggested already:
-Infinity, based off the concept that the languiage can be applied to any number of situations, and can be used from the smallest to the largest programs.
-Wolf Pack, based off a similar concept. Packs of wolves can range from large to small, and each wolf can function as its own self, or as part of a large pack, or in this case a large program.
-Multricana, based off the latin word for Harmony, which also gives a close resemblance to “Multiple”. The language has a vast amount of options available to it, all of which can work together in harmony. (The word is modified to be somewhat more whimsical. The original word is Multicanas, which is also a viable name itself.)

The name is itself a language construct
The implied Universe function takes the language as the input.
W resembles a sinusoid – fundamental signal
W is an atomic element – symbolically indivisible, dense, hard

Strangely, it has always been my impression that the language behind Mathematica was officially called Mathematica. “Wolfram Mathematica” is the product, “Mathematica” is the language; that’s the way I always thought it is. There are even a number of books following that assumption, using “Mathematica” as excecuted in the “Mathematica” environment the same way “ABAP” is executed in the “SAP” environment, for example.

I wonder why you were referring to Mathematica being “more than mathematics” so much. Of course, it is more than what people would perceive as high school mathematics, but that is pretty obvious just by the scale of it.
Use “M*” to do calculus? Mathematics, obviously. Use it to find data? Set operations. Use it to create geographical charts? Graph theory with projection onto an ellipsoid. Use it in music? Scales, harmonies, all mathematical descriptions of a particular time-domain waveform. Correlating different sources of knowledge? Set operations again, with weights, sorting and the like. Image processing, perspective, pattern detection… It may be hidden and abstracted away by a high level description of the problem at hand, but it’s always there.

And then there is the greek “mathesis” root meaning “knowledge” (as you mentioned) or “learning”. That pretty much does nail it, doesn’t it? A language that automates knowledge processing. Mathe-matica. Like a math-o-mat, a learning-machine.
Clearly using it to this extent is a product of the extensive libraries Mathematica provides to support the language itself, but being able to formulate operations in a way that focuses on the task or data and not the computations behind it is a feature of the language.

And please, for the love of it, don’t be another Thee Letter Language Ending With “L”. There are enough of those out there, most of them being utterly useless outside of a very specific (usually entirely academic) domain. You would not want to be perceived that way.

How about Ponte (bridge?) A tool, a structure intended to carry, support and allow exploration, an enabler (to cross a gap); invokes a sense of architecture, etc.

It seems to me that a name which embodies both a concrete and abstract balance or sensibility would serve well; attempting to use a name that describes a singular aspect of Mathematica (symbolic, numeric computation, algorithmic, knowledge portal or other nature) seems destined to fall short. In which case I suppose one might still be left with choosing a name for basic branding reasons, perhaps a letter like W, or a famous mathematician’s moniker, etc.

Bridge or Ponte or some variant (Arch? Arc?) feels like it has this sense of balance. It also invokes the idea of both building a bridge, and *having* a bridge, concurrently, which I think is also true of the Mathematica system, so to speak.

Why not… if you are open to an outside idea for the name of the Wolfram language, then are you open for an idea about the mother of all rules? Or is that something strictly kept to yourself? Is there a prize? Is it something Wolfram publishing would consider?

So your name must be simple, it must communicate meaning inherently and be understood by a wider audience. Here is my suggestion for a framework:

INTRA

“But in our language—built right into the language—is a huge amount of computation capability and knowledge.” your words

Intra is the latin root for “within”. From all that you describe about the language and it’s capabilities, it seems like a good fit. Also, INTRA can be regarded as a shorten version of IN TRANSLATION as a reference to a function of language itself. Thus we have,

I read your blog several times and you have already named the critical associations a name for the language should carry which suggests to me an idea. But first, from my reading you also seem pretty set on using ‘Wolfram’ as part of the name. I agree, but I think you should only use the ‘W’, not the whole word (mostly for these two reasons:

- (1) It’s already 2-3 syllables, depending on how it’s pronounced, and you know how people can be, especially Americans, about long names for anything. If it’s any length people will slap their own ‘shorty’ on your name and – assuming its popularity (the language, not the name), which I don’t doubt you’ll be forced to live with a name you might not like;

- (2) As you yourself say about the name ‘Wolf’: “Unfortunately wolves tend to have scary associations..” as would be the case in a name with ‘Wolfram’. It’s also presently the case that ‘Wolf’ and ‘wolves’ still has a medieval connotation in many parts of the globe, and tribal connotations in other. Noble as the creature is it’s not a name that conjures a 21st century ‘we can build anything with this’ feeling. Still, I like the icon a lot. ‘Wolf*’ not so much.

Three (3) striking and deep things you said touched me and I think echo the power and reach of the language (as I intuit its possibilities from your blog and its singular expression in ‘Mathematica’):

(i): You say “Our language, though, works in a somewhat different way from ordinary human natural language—most importantly, because it’s completely executable: as soon as we express something in the language, that immediately gives us a specification for a unique sequence of computational actions that should be taken.” Wow! That’s awesome! A language that’s an ‘executable specification’! And one reflects on the kinds, range, depth and complexity of ‘stuff’ one can specify in just Mathematica, never mind the language it was built from! Bring on the language for this century’s creators bending space, time, imagination, and urgent need into today’s executive tools, services and products!

(ii): You say “But in our language—built right into the language—is a huge amount of computation capability and knowledge.” and “So while in some aspects of its basic mode of operation our language is similar to typical computer languages, its breadth and content is much more reminiscent of human languages—and in a sense it generalizes and deepens both concepts of language”. SO, this is a language not just for thinking and instantly creating (as in being completely ‘executable’ in a way and with a power and range most languages are not), but is itself a language with inherent knowledge and large, active computational capability.

And so, a language that thinks, perchance in the hands of an adept user, a language that dreams, and as T.E. Lawrence wrote: ““All men dream: but not equally. Those who dream by night in the dusty recesses of their minds wake up in the day to find it was vanity, but the dreamers of the day are dangerous men, for they may act their dreams with open eyes, to make it possible.”

(iii) You say: “We want a name that communicates the generality and breadth of the language, and is not tied to one particular application area or type of usage. We want a name that makes sense when the language is used to do tiny pieces of interactive work, or to create giant enterprise applications, and to be used by seasoned software engineers, or by casual script tweakers, or by kids getting their first introduction to programming.” Wow! That’s wide-spectrum. That’s deep field (Hubble deep field). That’s a promise of power in the hands of both one and many. And while Mathematica is “a system for doing mathematics by computer” the ‘W’-ish sounding language sounds like “a system for creating realities by computer.” From giant enterprise to kids just starting out, from star drive builders to sys admins whipping up a quick interactive script. I want one.

And my suggestion for a name, given the three points of yours I’ve only echoed above, is ‘Wish’. If anybody other than yourself called a language that (Wish) and promised (in the ‘new’ language) the capabilities you describe, then I’d probably try to order some of what I was sure they had been smoking because it would have to be some really good stuff.

However, you’re you, and I’ve both seen just a little of what you can do (Mathematica and it’s worldwide applications; NKS), and believe what you might do. I believe. And that’s all that’s necessary to start making wishes that work, that and speaking in the right language (Wish) with the power to make them come true. As Jean Luc Picard so aptly put it in Star Trek: The Next Generation: “Make it so”.

woof (n.2) dog bark noise, also see “woofer” which is a loudspeaker for bass notes”

“Warp and woof” is used to describe the foundation or base of any structure or organization, where that organization is metaphorically a woven fabric” with a “woof” that is threaded across the “warp.” In the case of the Wolfram Woof Language, Woof is threaded across the warp of our knowledge of the world.

“Woof” is also a sound made by dogs, and presumably the language of wolves when not howling!

Speaking Woof:

The Woof language is “a set of constructs that can be *strung* together to represent an infinite range of meanings.”

“We want a name that communicates the generality and breadth of the language’s *fabric*, and is not tied to one particular application area or type of usage. We want a name that makes sense when the language is used to do tiny pieces of interactive work, or to create giant (*textile*) enterprise applications, and to be used by seasoned software (*weaving*) engineers, or by casual script tweakers (*sewing in a few alogrithmic changes*) and , or by kids getting their first introduction to *”woofing” a program.”

“It’s a new kind of language *weaving knowledge together*. It’s *a computational loom*, but it also has intrinsic content: broad knowledge (*warp*), structures and *weaving* algorithms built in. It’s a language that’s highly scalable: good for programs *and fabrics* ranging from the absolutely tiny to the huge. It’s a very general language, useful for a great many different kinds of domain *fabrics*. It’s a symbolic language with *a very clear warp* and very clear principles, that can describe arbitrary structures as well as arbitrary data. It’s a fusion or *weaving* of many styles of programming, notably functional and *pattern* based. It’s interactive *like weaving.*. And it prides itself on coherence of design *(i.e., it’s “warp and woof”)* , and *like a loom* tries to automate as much as possible of what it does.”