In the early days of Fortran, language syntax was described by a bunch of English text and handwaving, implemented by ad hoc logic. Neither the compiler writers nor users really understood what the compiler was supposed to be doing, leading to endless misunderstandings, incompatibilities, frustrations, and wasted effort.
The introduction of phrase structure grammars for specifying programming language syntax together with LALR(1) parser theory and practice for implementing them changed all that: Ad hoc hacking and guesswork were replaced by engineered precision establishing a clear distinction between bugs and features.
But these are still the bad old days when it comes to mainstream language semantics. Language syntax is precisely described, but when it comes to what that syntax means, the discussion reverts to English text and handwaving, with the inevitable consequence of endless misunderstandings, incompatabilities, frustrations, and wasted time.
At the semantic level, contemporary mainstream languages were not actually designed; rather, a grab-bag of cool-sounding features was thrown in a pot and the compiler writer asked to somehow make them sorta work together.
In general, unsurprisingly, this turned out to be impossible.
For example, in both
C++ and Java the typechecking problem turned out
to be provably undecidable, meaning that it is mathematically impossible
to produce compilers for those languages which accept all valid programs and
reject all invalid ones.
That makes such languages weak foundations upon which to build production software systems; if you cannot trust your compiler, where does that leave you?
The semantics of SML, by contrast, was rigorously engineered from the start. It is specified not by mumbling and handwaving, but by a mathematically precise definition. Based on that definition, properties like typechecking decidability were mathematically proven. (The original 1990s proofs were checked manually. Today those properties have mechanically verified proofs, courtesy of much work at CMU by Robert Harper and a stream of doctoral students.)
Consequently, SML may reasonably be regarded as the first fully modern programming language — the first programming language precision engineered rather than just hacked together based on guesses, hopes and prayers.
Mythryl inherits that clean semantic structure from SML and adds to it various refinements irrelevant to a lab prototype but critical to production use.
Mythryl may thus reasonably be termed the first production software engineering language.
(An extended discussion of this point may be found here.)