IYH Dear Ziad Rabea

Very nice idea. Here's some history on such an effort: Visual Basic for Applications (VBA) has an interesting multilingual history, especially during the 1990s and early 2000s. Introduced in the early 1990s, VBA was designed as an event-driven programming language for Microsoft Office applications, including Excel, Word, and Access. While English was the primary language for VBA during its initial release, Microsoft soon recognized the need for multilingual support to cater to a global audience.

In the mid-1990s, Microsoft released versions of VBA with localized language support. This meant that VBA code could be written and executed in various languages, enabling developers around the world to create applications in their native tongues. The localized versions of VBA included support for different character sets, such as double-byte character sets for East Asian languages, enabling the display and manipulation of complex scripts.

By the late 1990s and early 2000s, VBA had become widely adopted, and its multilingual capabilities continued to evolve. Microsoft further enhanced VBA's language support, ensuring that developers could work with a broader range of languages and character sets. This period also saw the emergence of online communities and forums where developers from different parts of the world shared code snippets, discussed best practices, and collaborated on projects, fostering a vibrant and diverse VBA programming community.

In 2002, Microsoft took another significant step in the multilingual evolution of VBA with the introduction of the VBA Language Reference for Office. This comprehensive reference documentation was made available in multiple languages, providing localized resources for developers to learn and reference VBA functions, methods, and properties in their native languages. The VBA Language Reference covered various aspects of the language, including syntax, examples, and explanations of VBA elements, making it a valuable tool for developers worldwide.

The multilingual capabilities of VBA played a crucial role in the widespread adoption of Microsoft Office applications, particularly in international markets. It empowered users and developers to create customized solutions, automate tasks, and develop applications tailored to their specific language and cultural needs. The evolution of VBA's multilingual support during the 1990s and its continuation in the early 2000s contributed significantly to the flexibility and accessibility of Microsoft Office as a development platform for a diverse, global audience.

The multilingual capabilities of Visual Basic for Applications (VBA) during the 1990s and early 2000s brought about a range of exciting features, fun possibilities, and unexpected challenges:

**Language Support and Localized Versions:**

- Variety of Languages: VBA supported a wide range of languages, including European languages like French, German, and Spanish, as well as East Asian languages such as Japanese, Chinese, and Korean. This enabled developers to create applications in their native languages, making it more accessible and intuitive for local markets.

- Localized Functions and Keywords: VBA functions, keywords, and built-in functions were translated into different languages. For example, the "MsgBox" function, used to display message boxes, would have localized equivalents in other languages, allowing developers to code in their own language.

- Double-Byte Character Sets: VBA provided support for double-byte character sets, which are essential for displaying and manipulating complex scripts used in East Asian languages. This enabled the accurate representation and processing of characters in languages like Chinese and Japanese.

**Fun and Creative Possibilities:**

- Internationalization of Applications: Developers could create applications with multilingual user interfaces, allowing users to interact with the application in their preferred language. This made VBA-powered applications more inclusive and user-friendly for a global audience.

- Cultural Customization: VBA enabled developers to incorporate cultural nuances and localize content. For example, date and time formats, currency symbols, and even color choices could be tailored to specific regions, enhancing the user experience for diverse audiences.

- Multilingual Reports and Documents: With VBA, it became possible to generate dynamic reports and documents in multiple languages. This was particularly useful for businesses operating in multiple countries, as they could automate the creation of customized reports for different markets.

**Unexpected Challenges and Pitfalls:**

- Translation and Localization Issues: Translating VBA code and documentation was a complex task. Inconsistent translations or misunderstandings could lead to confusion among developers, especially when working with code examples or referencing documentation in different languages.

- Character Encoding and Compatibility: Supporting multiple character sets and encodings could lead to compatibility issues. Mixing character sets within a single application or document sometimes resulted in garbled text or display issues, requiring careful handling of character encodings.

- Language-Specific Syntax and Idioms: Each language had its own idiomatic expressions and syntax constructs. Developers had to be mindful of these differences to write efficient and readable code. Misunderstanding or misapplying language-specific idioms could lead to errors or unexpected behavior.

- Online Community Fragmentation: While online communities brought developers together, they could also become fragmented due to language barriers. Developers might miss out on valuable resources or discussions happening in other languages, limiting their access to a broader knowledge base.

- Performance Impact: The use of double-byte character sets and complex scripts could impact performance, especially in memory-intensive applications or when working with large amounts of text data.

The multilingual journey of VBA during this period was a fascinating aspect of its development, opening up new possibilities for developers and users worldwide. It also presented unique challenges that needed to be addressed to ensure a seamless and consistent experience for all users, regardless of their language and cultural background.

Dear Dr. Bilar,

Thank you very much for your detailed and insightful response. I greatly appreciate your sharing of the historical context and evolution of VBA’s multilingual capabilities. Your account of the challenges and creative possibilities encountered during VBA’s development provides valuable lessons and inspiration for further development of WorldLang.

Best regards,

Ziad Rabea

Dear Ziad Rabea ,

By taking a multilingual software development approach, you can improve the efficiency of your localization processes, reduce translation cost, and provide a better experience for your software's international users. Here's how you can switch to a multilingual software development process.

https://www.linkedin.com/pulse/multilingual-software-development-key-successful-global-product-jflwc/

Regards,

Shafagat

A multilingual programming language has the potential to democratize coding, making it more accessible, inclusive, and culturally diverse.

It could lead to significant advancements in education, collaboration, and innovation in software development.

Dear Ziad Rabea ,

I think you pose an important question and your project sounds interesting. It does seem similar to the multilingual VBA facilities suggested by Daniyel Yaacov Bilar . A different perspective might be found in the project which I have been developing for a few years now, and which may be of general interest to this thread?

The traditional arguments against programming in natural language have been it ambiguity and context dependence, nothing proves that it cannot be done, it's just that we haven't discovered how to do it.

I have developed a functional user-defined symbolic system which is Turing Complete. This means you create 'symbols' which can be arranged as functions using branching and loops. Rather than working with words, a symbol is a complete utterance, whatever can be generated by speech-to-text software, and can be from any language. An example of creating language can be seen in https://www.youtube.com/shorts/PgodIycEMO4

Therefore by voice, you have direct access to the computational abilities of a device, without having to write a program (a fixed executable artefact) I fully admit that I have not tried this yet in non-ASCII characters because, to my shame, I am a mono-lingual English speaker!

My latest paper, currently out for review, which explains what is a simple idea by comparing it to Turing's original Universal Machine is at https://www.researchgate.net/publication/381479109_A_Universal_Machine_for_Speech_A_Universal_Machine_for_Speech_A_Universal_Machine_for_Speech

The ideas in this project were developed in the 1950s and 60s (they're not mine!) and follow the principles of Ordinary Language Philosophy. https://en.wikipedia.org/wiki/Ordinary_language_philosophy

I hope this is of some interest. In the meantime good luck with your project.

Martin

Dear Dr. Wheatman,

Thank you for your insightful and encouraging response. I found your project on a functional user-defined symbolic system absolutely fascinating and innovative. The idea of creating symbols as complete utterances, accessible through speech-to-text, is a remarkable approach that indeed addresses some of the traditional challenges of programming in natural language.

I am currently working on a vocal compiler that aims to revolutionize the programmer-computer interface by moving beyond the traditional input/output paradigms. In our project, code can be stored as an audio file, and we are also exploring the use of a smart glove to help people code in sign language. This approach aims to make programming more accessible and inclusive, allowing for new forms of interaction with computational systems.

Your work provides a rich context for our endeavors, and I see a strong potential for synergy between our projects. I would be very interested in discussing the possibility of future collaboration, as I believe our combined efforts could lead to groundbreaking advancements in this field.

Best regards,

Ziad Rabea

Dear Ziad Rabea

Thank you for this kind reply.

Sound files+compilers sounds interesting, but you would have to talk in computer code, speaking source. So not only do you have to program you also have to perform.

The data glove is an idea I've toyed with for some time. The technical issue is turning arbitrary movements in a glove into a token (a number or string) with repeatability, much like turning an arbitrary sound packet into text with repeatability. While all my unit tests use written utterances, I exploit the speech-to-text facilities of Android when making Android apps.

And yes, collaborative approach would be appreciated!

Martin

This is definitely not the first attempt. Around the year 2000, schools in Poland had the ALGO program, which was a compiler of the simplified PASCAL language.

It could theoretically use any set of keywords, and in fact there were Polish, English and some Cyrillic versions. Probably Ukrainian.

Of course, it was not a commercial solution, but it was very helpful at the initial stage of learning programming.

I still remember a problem that occurred with this tool.

Well, user-defined identifiers in one language, after translation, could be identical to keywords in the other. Between Polish and English, this is rather a rarity and a "natural curiosity", but if you take 100 languages, the possibility of such a situation increases significantly. This could be avoided by enforcing special marking of keyword, but it is certainly a problem that must be solved somehow.

"The special marking of keywords" WOJCIECH BORKOWSKI is used in CORAL-66 where the keywords are surrounded by 'single' 'quotes', just so that identifiers can have spaces in them. Yet another dead language :^)

Writing compilers is a fascinating subject, but the real trick is to get away from keywords and tokens altogether :^)

Joking apart, it's not APL ;^) What I'm doing is removing the need for source code as a high level representation of machine (or target) code, by creating a self-described functionally-complete machine code.

Turing described a Universal Machine as an algorithm (a FSM) on a tape, which generates a (transcendental) number on that (endless) tape. Von Neumann developed this into a program in memory processing data in memory. The arduous task of writing machine code for this architecture was mitigated by introducing high-level languages to be translated into machine code.

My method is a Turing complete system from arbitrary arrays of strings or utterances, so it can be seen as monadic. With a small initial set of utterances to create functions we can convey computationally complete systems into machines. Being able to tell a machine how to understand an utterance by what it implies, in further utterances, represents machine understanding; you can access to the computational abilities of a device by values generated by speech-to-text software, there is no "ghost in the machine".

An example of a recursive function in source code might be:

int product( int x, int y ) { y==1 ? x : x + product( x, y-1 );}

The decision to terminate this recursive function is within the code, the y==1 conditional (trinary function). It is called by writing:

int x = product( 2, 3 );

In Enguage, this function is created by saying:

"the product of x and one is x"

"the product of x and y is x plus the product of x and y minus 1".

There are two 'signs' in each recursive function: the looping one and the terminating one. The system decides which one to use by simple pattern matching. It is called by saying,

"what is the product of two and three".

This ostensibly data processing system comes into its own when processing non-numerical functions, such as the processing of ethical statements.

This could be called 'functional linguistics', but this space has been hijacked by the structuralist approach to language, which is based on the dualist/dyadic idea of syntax and semantics (which we see as source code whose semantics are described in machine code).

The problem I've grappled with for the past 10-12 years is in persuading publishers that I'm not some Alice-down-the-rabbit-hole, that this idea is evidenced by software, and that this research is novel. My work is often rejected without review, I suspect because of a lack of 'experts' to review my work; however, I typically get generic comments about the quality of my work. I do crave feedback and (valid) criticism! I did win the BCS SGAI Machine Intelligence Competition in 2016, but this success is now drowned out by the noise created by the hopes and fears over generative software.

Sorry, if this sounds like a rant ;^)

Thanks for this reply, and thanks for putting up with me! You're making valid points about source code and silicon, and I get it, but it shows I'm not explaining my work very well. Please keep going :-)

I'm not trying to make silicon understand high-level languages at all, I'm removing the need for source code from the process of speech understanding. I use speech directly as a computational device: a low level language. All this requires is two small changes to Turing's original Universal Machine idea: large valued symbols and a symbolic function mechanism. Sorry, if I've not been clear on this.

The output from a speech-to-text software, an utterance, is a large numeric value or symbol. That symbol serves as input to a function written in further symbols. If the reply (the returned symbol) is optionally prefixed with "ok" (the default), "yes" or "sorry", "no", and the calling function can use this to direct the flow of control, with "if so, ..." or "if not, ...". Then speech is Turing complete.

This is not wishful thinking, or rabbit-hole theory, it is achieved in software by a working speech interpreter, Enguage, and it has over 500 test cases. It won the BCS SGAI Machine Intelligence Competition in 2016 (http://www.bcs-sgai.org/micomp/pastcomps.php). The source code is freely available on github and bitbucket (https:/bitbucket.org/martinwheatman/enguage) if you'd like to take a look. It typically processes the unit tests in about 6-8 seconds, but this time is extended as it includes a prototype Wikipedia page parser.

The "why bother" bit is that, so far, we have failed to understand speech. Yes, using Neural Nets we can successfully turn sound packets into text, but what that text 'means' is a mystery. Understanding is a dynamic system. If I were to say, "to the phrase hello reply hello to you too", this modifies our understanding, on the fly. See https://www.youtube.com/shorts/PgodIycEMO4 as an example. It's the source code artefact which scuppers the 'on-the-fly' bit.

• ELIZA used keyword search (pretty much like Google search, with stop-lists), and chatbots have been designed to maintain a conversation ever since. The example I originally typed in was from David Ahl's More BASIC Computer games, in the 1970s.
• Alexa works in a similar way, using JavaScript to parse what has been said; however, again, to understand it requires source code to be written and published (through Amazon's dev site).
• While ChatGPT is the latest thing, and garners much interest from the AI community, my conjecture is that it will never be trustworthy because it is based on probability: it is not deterministic.

The philosophy behind this (Ordinary Language Philosophy), of things meaning what they imply, was being developed in the 1950s, about the time the first compilers were being developed, but has never been exploited (as far as I know!) until I picked up this thread in my PhD and post-doc research.

Hope this is of interest!

A multilingual programming language could revolutionize software development by enhancing collaboration, increasing accessibility, and simplifying the learning process. Developers from diverse linguistic backgrounds could code in their native languages, improving readability and reducing errors. This inclusivity would open the field to a larger global talent pool and foster innovation. However, challenges in standardization and translation accuracy would need to be addressed to ensure consistency and interoperability. Overall, such a language could democratize programming, making it more inclusive and diverse.

WOJCIECH BORKOWSKI

Dear Dr. BORKOWSKI.

My words fail to express my gratitude for your priceless and invaluable notice, I promise to take it into consideration.

Best Regards,

Ziad Rabea

Peter Breuer Again, thanks for your comments: anything to help me think about what I’m doing, and to improve my explanation, is very welcome!

I think you’re probably right in your summary that Enguage is, essentially, a “compiler-compiler written as a rewrite rule machine”, if I understand that correctly. But it doesn’t use traditional lex/yacc type tools, where the compiled language is specified in some other syntax, and which ties you to a written artefact: speech is self-defining. Think of how the English dictionary is written in English.

One inspiration behind Enguage, perhaps, is John Searle’s Chinese Room, but one where the ‘rule book’ is created and used by the people outside of the room. My argument is that a ‘rule to create a rule’ is not axiomatic, it doesn’t require some special rule-syntax, it is an arbitrary proposition: a spoken ‘idea’.

“I use speech directly …” is my justifiable claim that ideas are Turing complete which shouldn’t be a surprise: as you’ve said yourself, a lot of things are. The 'computation' is in passing ideas between people, and ultimately, machines. If I can persuade you, for example, which tree contains the best honey, I've built and idea in your mind. So, the important word here is ‘directly’, there should be no special syntax.

My purpose, the ‘why bother’ bit, is to remove the written artefact to create a talking machine. This may, in turn, suggest answers to the role the FOXP2 gene plays in speech?

For Enguage, each utterance as an immutable symbol, so “I need a coffee” and “I need a tea”, are different symbols. Each are swapped, arbitrarily, for their own reply, e.g. “okay, you need a coffee”. It does use a simple pattern matching algorithm to allow these two symbols to use the same description, but I digress… . It is possible for one symbol to have >1 meaning, so there is a protocol (as seen in human conversations) which allows the speaker to determine the one they mean. This simply requires that each symbol swap is unique.

I agree that the “to the phrase …” example will not tax your intellect, it is only meant to be a simple example. However, this illustrates how the interpretation of a phrase can be introduced by voice. My definition of Machine Understanding is "the conveyance of, and subsequent interaction with, ideas within a machine" (see: ISBN:979-8-89113-585-7). Perhaps, I need to create a more sophisticated example which shows how we attribute ‘further meaning’ to this initial utterance/reply swap?

Hope this is still of interest.

Kind regards,

Martin

PS. The “speech-to-text software” I use is provided by Android – the inclusion of “a” is a typo, my bad! In 2013, I re-wrote Enguage in Java so that I can embed it within an Android app, which I released onto the Google app site. But I had little success in marketing it, and while I occasionally reinstall my own phone, I’ve concentrated on improving the core idea. Like you say, it’s one thing I needn’t bother with!

PPS. I use the word ‘function’ to mean the formal representation of an algorithm, as defined in Church’s lambda Calculus or its modern counterparts. I tend to use a C-like syntax in examples. As I understand it, all arithmetic can be defined with the add() and negate() functions. The linguistic corollary is that all language can be defined with iCanSayX(x), whereXisaVariable(x), thisImpliesThatX(x), thenX(x). I just don’t present this as source code, as a ‘special syntax’.

Peter Breuer Likewise, I don't understand what you don't understand :-/ BTW, I do know what yacc is :-) , I'm just trying to get away from the idea of writing (or generating) source code as an intermediate step.

I'm not sure what you mean by "computer science style". The second para makes sense an sounds a bit more like Enguage. And nope, its not difficult, its not doing anything 'special'.

A simple text interpreter, think of Alexa, might be written (something!!!) like this - it doesn't seem to want to format :( .

String interp( String str ) {

if (str=="thank you") {

return "you're welcome";

} if (str==”hello”) {

return “hello to you too”;

}

return “I don’t understand”;

}

If you want to expand its understanding, you'll have to write more source code which is what I'm getting away from.

In Enguage, this may be represented in text as:

• On “thank you”, reply “you’re welcome”.

These are signs, in common parlance “an information atom”, but this doesn’t need to be written like this as context free source code, it can be described in speech:

• To the phrase thank you reply you are welcome.

To add more meaning to a sign we can imply what it means:

• To the phrase I need a coffee reply okay you need a coffee.
• This implies that you add a coffee to my needs list.

And

• This implies that a coffee exists in my needs list.
• Then if so reply yes I know.

The sign, just constructed, may be saved as:

• On “I need a coffee”:
• a coffee exists in my needs list;
• if so, reply “yes, I know”;
• add a coffee to my needs list;
• reply “okay, you need a coffee”.

There are one or two simple tricks, such as (very simple) pattern matching but this is context free nor context dependent ‘syntax’. I’ve over 500 unit tests in my system/regression test, and I’m not going to type them all out here. It all works, that's the main thing, and its free open source code - download (git clone) my code, from https://bitbucket.org/martinwheatman/enguage, and run the full test for yourself :).

Is this the computer science style you’re looking for? The interesting thing is that this functional approach to language understanding was devised in 1923, around a decade before Church’s Lambda Calculus. See the 'Triangle of Reference' on Wikipedia.

Peter Breuer Thanks for your reply - and sticking with me! And putting up with my ignorance of computer science, too! ;^)

Sorry, I'm sure the compiler-compilers I used as an undergraduate in the 1980s used to generate the source code for the compiler. Of course this could be compiled directly, but it still forms a manual break in the creation of software (manually *editing* the language definition files and running the compiler-compiler) The understanding of speech is continually being updated, on-the-fly, through the speech that is used.

"Please do [define your language grammar and define the domain of interpretation, and define the interpretation, _formally_.]."...

Yes, ok, but this goes to the heart of the problem. Natural language, speech, cannot be defined formally, it is not algorithmic. Formal definitions rely on writing and the written artefact; however, writing is only about 5000 years old. Speech is *much* older ;^)

Many people throughout the C20th, however, have taken a formal, or 'structural'. approach to language. I'm currently working my way through Montague Semantics which expresses the 'meaning' of a sentence in FOPC/set notation, which looks a lot like Z.

Structuralism does work in context-free languages in computing. Turing's PhD thesis shows that Church's Lambda Calculus can be implemented using his Universal Machine, and so defining Turing Equivalence. This manifests itself, today, in the idea of a compiler translating source code into machine code. But the culmination of this approach in understanding is Alexa. Imperatives are structural, but speech is not simply a litany of imperatives. See my article in ITNow: https://academic.oup.com/itnow/article-abstract/59/1/48/3061296

The post-structural approach to speech, aka Ordinary Language Philosophy, was developed in the latter half of the C20th, where *meaning is defined in the words used*, not in an underlying formal representation. Enguage is an attempt to implement these ideas, which involves an arbitrary transformations, relevant to all natural languages, and so is relevant to this thread.

The best explanation is that speech is like Turing's Universal Machine, see: https://www.researchgate.net/publication/381650482_A_Universal_Machine_for_Speech

The UM idea is of an endless tape consisting of pairs of E- and F-squares: [A|B|...] => [0|1], so it is structurally based, containing the name/value pattern which is found throughout computing (think of variables, or filenames and their content). However, with Enguage all values (A, B, ..., 1, 0) are all lists of strings and that the referenced value is, itself, interpreted to obtain return a value.

To save your sanity, I will spare you the examples from the previous post ;^) However, one comparison might be in the question, "what is the meaning of 'yes'?" The structural approach would say 'yes' is a value: a positive affirmation to some question. In a post-structural world, we'd say: "to the phrase can i nave a biscuit, yes would imply have a biscuit". The post-structural idea is language agnostic, because it defines what an utterance means not what value that the name 'yes' holds. Does this help?

I will say that this _might_ have implication for the decidability of mathematics, because while speech defines its own mechanism, it seems to use sub-mechanisms which control interpretation. We give answers prefixed with "yes, ..." and "no, ...", or their language specific alternatives (oui ou non?) and these are directed by the original question, e.g. "do we have any bananas?" or "don't we ...". We also control the flow of interpretation using the replies, using terms like "if so, ..." and "if not, ...". This must be meta-speech inside speech: "If not, speech won't work!"

Hi again Peter Breuer , I'm afraid I can't do any more for you, not because I don't want to but because you seem fixed on the idea that speech is based on structuralism, that it has a context-free syntax, and so can be expressed in "computer science style". This is a common and unproductive misconception of the C20th.

I will repeat, natural language is what is known as context-dependent and hence needs a post-structural approach, such as that proposed jointly by the Ordinary Language Philosophers the 1950s. I have written an arbitrary string interpreter, Enguage, to implement their ideas and which works as speech interpreter. Further, it is not dependent on English which makes in relevant to this thread. Furthermore, is not a compiler, nor compiler-compiler, which are old (yacc was written in 1970!) and well understood technologies which exploit context-free languages.

If you were my student, I would have to be firm and ask you to run the Enguage test suite and take a look at the output, before we can progress. Its output is plain language, and the functional approach to speech should be recognisable to anyone well versed in computer science. You have free and open access to this source code which won the BCS SGAI Machine Intelligence Competition in 2016.

If you are unwilling to do this we cannot progress any further. If you are unable, or need any help with cloning a git repo, or running the Java compiler, instructions are in the README in the repo. Or get back to me, I'm here to help!

Many thanks, Martin.

No Peter Breuer , *you* are talking about context-free syntax in your proposal that "language = sentence*; sentence=word+". You then talk about defining its semantics when you say: "All you need to do on top of that is define what you do with that input". Yes, this dichotomy between syntax and semantics may be the "computer science style" that you seek, computer science is riven with this dualism, and it is exactly what prevents the development of speech based systems and the realising machine understanding. Please read any of my papers, articles or journals before you ask for more information, *please*.

Your claim that this is the "intellectual effort that has to be made in order to get ideas over" is simply closed thinking: can't it be anything else? Hint: speech gets ideas across. Whenever you prefix a statement with "It's bound to be ...", again this is closed thinking, you're explicitly creating an explanation which fits in with your own world view.

*I* do not need to say anything more: I've asked you to run my code, which you've not done, you've clearly not read anything that I've posted (or none of it has sunk in), nor read any of my peer-reviewed papers, articles, nor my thesis on machine understanding. It's all there, it just doesn't fit in with *your idea* of [["computer science style"]], but that's the whole point of *new* ideas.

Also, you need to stop masking your failure contemplate new ideas by trying to diagnose my ignorance - 'bootstrap [myself] up on computer science' indeed! At best, it is patronising, but, "FYI", it can be sloppy thinking: your definition of 'abstraction' as being a 'huge sweeping abstraction' contains a circularity.

*Please* read what you write before you post.