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.

2 the process or action of bringing about or giving rise to something: isolation, starvation, and other forms of stress induction.
• Medicine the process of bringing on childbirth or abortion by artificial means, typically by the use of drugs.

3 Logic the inference of a general law from particular instances. Often contrasted with deduction.

Mathematica certainly helps people give rise to their ideas, creations and amplifies a persons ability to express those ideas. It also allows one to define those ideas in a extremely logical way and as you mention with a general syntax and approach (law) for how to express the ideas that your team has applied across many domain areas and conceptual areas.

I did grow up with personal computers and of course Mathematica, as many others from my generation. So I find it thrilling to be allowed to suggest a name for the core of Mathematica. There are many great suggestions in the comments, so the name is maybe already chosen. But anyway, here are my 25 cents. (English is not my native language, so please bear with me

First, I want to sketch the requirements and thoughts, as I read it from above:

Instead of random name, it should capture the essence of what is to be named. There is a need for a short but familiar name with a certain classical stylishness to capture almost a completely new concept. The name should communicate the generality and breadth of the language, which is not tied one particular application area. It must make sense when used in very small work as well as in huge enterprise applications. The name should be able to go with …language.

The “language” is about much more than a math.
The “language” is completly executable .
The “language” has a huge amount of computation capability and knowledge.
The “language” functions and structures automates a vast range of computations and deliver immediately usable knowledge.
The “language” is not like other languages. It’s computational, but also got intrinsic content: broad knowledge and algorithms build in.
The “language” pride itself on coherence of design, and tries to automate as much as possible of what it does.
The “language” progamming can be called “hyperprogramming”, “metaprogramming” or “macro programming”

Some thought of using “M”, “Wolfram” or “Thema” (from: ma-thema-tica) among many others.
Some thought of combine name with f.ex. -script and -code or prefix it with cyper-, proto-, mega-, neo-, super-, ultra-, poly- and so on.

…

My absolute initial thought was: “Matica” which not only have a clear connection to Mathematica but kind of contains the performa part of the word “mathematica”. It sounds familiar without narrowing the “language” to only math. “Matica” would satisfy many of the above requirements in my opinion.

But maybe it would be better to go for “Matic” as: “mathe-matic” without the trailing “a” in “Matica”. “Matic” has the same connection as “Matica” but also lead the mind to “automatic”. As a bonus, it sound a little as “magic”. “Matic” is also used for something which is “cool”, “awesome”…. “this is so matic”.

One option is, to prefix it with “e”: “eMatic”. The “e” prefix can be the “e” from “math-ematic” or “e” in “electronics”. But other prefixes goes very well as: HyperMatic, CyperMatic, MegaMatic, UltraMatic, or suffixes as MaticCode, eMaticCode. Smal scripts can be named “tics” or “matics” .

How does this sound:

The eMatic language functions and structures automates a vast range of computations and deliver immediately usable knowledge to the user.

Using MaticScript and MaticMacros are easy and flexible and yet powerful…

Let me take this one step further without loosen completely the initial thought:
“Mathematic” – “automatic” -> “automation” -> “automaton” -> “auto-matos”. Greek: “-matos” > “to act” or “to think” -> “Matos” > “Thinking” (twenty years of thinking . “Matos” or “MatOS” -> The Mathematics Operating System. Well… it’s probably not he case, but I’m just playing with combinations. So lets try this with some pre- and suffixes :

HyperMatos, CyperMatos, MegaMatos, UltraMatos and MatosCode.

Then it will sound like this:
The Matos language behind the Mathematica pride itself on coherence of design and automation of complex structures.

In cognitive psychology, memory retention is said to be enhansed by what is referred to as, “depth of processing”. The more interconnected a semantic web is, the easier it is to recall something related to it. I think depth of processing might be a useful part of your language name.

One of the major issues with programming languages that is easy to forget about is that the tool chain for a language is extremely important. There are those languages that are designed for making the processor efficient. These languages are basically a Domain Specific Language for a Von-Neuman machine. Over the years computation has become cheap and memory access now dominates and our languages don’t lets us speak well to cache and memory bandwidth issues. Languages the are designed to make the people using them language be more efficient usually have an productivity environment and the language and environment become inseperable. This was the case with Smalltalk-80. Lisp and Emacs are one. Imagine Mathematica without the Notebook.

It is sad that most languages are happy to be tied to an emulation of a teletype machine. C has a terseness that speaks to teletype era. APL and J still seem to limit their composable functionality to the number of glyphs you can put on the head of a selectric type head.

Back to the tool chain. Imagine how hobbled the world is because C uses a very poor text rewrite system for a macro processor. This gave macros a bad name. Lisp got macro mostly right but they abandoned FEXPRS which were like Mathematica’s Hold Attribute family.

Typical batch languages have a fixed abstractions and are blind to the code people put in libraries. Subsequently library developers design them in such a way that the programmer has to try to play optimizer. There is no notion of compiler plug in so that the library and the compiler can act as a team. Of course this is exposing a problem with granularity. Function level granularity for compiling is often better but there is a spectrum in compiling that should be acknowledged.

The Go language is interesting because they are trying to address tools and tool chain issues. Go has a supported abstract syntax tree that is a standard of the language. This allows good tools to be developed with out having to make your own preprocessor. Mathematica with the universal Mathematica Expressions is wonderful because it has that standard AST.

I think I like Wolfram Programming Language (WPL) the best for the language but I am suggesting coining Wolfram Tool Chain to go with it in an inseparable way. They are duals.

My first reaction is agreement with those who said “Mathematica”. We’ve been calling the _language_ Mathematica, not just the software, the IDE. Yes, it involves the continual explanation that Mathematica is used far beyond mathematics, but then too, mathematics is used far beyond the associations of the word for the average person. So why struggle to change the de facto name?

(Quick side issue: loved the linguistic references in the post, but caught one typo in the Greek: κυβερνητησ should have been κυβερνητης. Other Greek words nearby correctly written with the terminal sigma character (“ς”), but that one incorrectly used “σ” at the end of the word.)

Second, whimsical thought, combining the “Wolfram” theme (brand recognition), a nod to Perl (multiple amusing phrases routinely used to explain the acronym, such as the backronyms “Practical Extraction and Reporting Language” and “Pathologically Eclectic Rubbish Lister”), and finally the idea one responder suggested that if the name is too long, it will be shortened to a nickname anyway: So why not call it … WHAM! It can be viewed as a contraction of Wolfram (“W..am”), or as Wolfram Hyper-Algorithmic Modeling (or Modeler or Metalanguage) or …. Lots of way to fill in the blanks, but if you need a quick and powerful solution, use WHAM! What a motto, too! “Need results now? Use WHAM!” Only question I have left is: should the exclamation point be part of the name or not?

It seems to me that the purpose of a language is to communicate with other entities. In the case of the “Wolfram Language” (WL for short) it is to communicate with a computer. A name should convey the communication aspect.

There are similarities between the natural (human) languages and the WL. The natural language and WL expect always a feedback: an answer to a query, the execution of an order, or a smile (not there yet in WL, in general a change in the internal status of the receiver).

There are two main differences between the natural language and the WL. The first is that the natural language is often ambiguous, while the WL is precise. The second is that the WL communication contains the algorithm that has to be executed (that it is why it is precise).

A name that conveys all of he above is not easy to come by, and perhaps WL should be adopted just before with the years has come to represent all the meanings it covers. Other names could be “Constructa” (with all possible variations), or “WolfSpeak”.

As Dr. Wolfram already addressed in his query to the issue of the Wolfram language….., not so much “modelica”, but the word “Mode” (long O), as Mode is easy to remember, easy to pronounce in any human spoken language, and most of all, easy in its context. Additionally, leave the word “language” out of it, as the future will not include the word “language” and will not need to anyway. Dr. Wolfram is well known visionary, and Mode would be the future of his and our “componentized” symbolic and multi-paradigm human computational needs.

Call it : Logos
The reasons why are obvious, right?
It relates to language.
It relates to science.
It’s an importantly broad and deep knowledge-related word with a long and venerable history.
It’s short and sweet.

Universal or some variation or integration Wolfram Universal Language WUL you can even pronounce it informally WL

it has Uni as unity it contains at least phonetic suggestion of word universe and it probably has routes from word universe anyway
and “vers” as in versatile and all those words are integrated in this one word representing (integration) and the word itself suggests
availability and application to anyone for anything for any purpose
+ universal is kind of universal word in many languages its written and sounds similarly
+ isn’t the U (Union (set theory)) symbol both in math and mathematica operator and if you put it as suggested(WUL) it will have even more sense , meaning and reference
+it’s kind of compound word representing wolfram language structure and usability aspects
Unity and versatility and accessibility and more
Uni(ty) (Uni)vers(atile) al(l)
I can go on and on …
Anyway simplest logic
Universal, intuitive word it seems to me
And immediately tells the user thet is probably something that can help him with whatever he does and its meaning , reference or symbol candy for experts
Ultimately
Universal is universal word (in this case very suitable(considering mathematica and wolfram alpha aplication range ) and if it was based on http://reference.wolfram.com/language/ alone it’s appropriate enough )
This is a marketing issue and although not marketing expert

The obvious answer, at least obvious to me, is Wolf. First of all, it is strong and short. It pays homage to Wolfram, as it should. As a symbol, a wolf is formidable on its own but, draws it’s real strength from working with others. Similarly, the language draws it’s strength from the built-in tools derived from the work of countless contributors, from Pascal to modern engineers.