In a lecture, Klaus Lagally presented us a thing possible in Cobol: DIVIDE CAKE INTO THREE.

I personally don't believe it's possible to turn people into programmers if they don't already feel a strong zest for it. Think of: I want the light switched on if it is dark outside, and I want the light switched on when it is 8 pm. Although the 'and' was used, a program would require an 'or' operation.

Regards,

Joachim

Probably Prolog is somewhere near to the given concept, considering it is a subset (I have in mind pure Prolog) of the Predicate Calculus, the more expressive formalism, on the one hand, and on the other, the traditional use of language words like predicates is a plus to give more "likelihood" to the Prolog expressions.

And talking about paradigms, I think in the same way that Patrick Winston, in his foreword of the known Ivan Bratko's Prolog text: Prolog Programming for Artificial Intelligence: Prolog and Logic Programming in general, are the most declarative language, and the most declarative programming paradigm, correspondingly ,up to now.

Clarence Lewis Protin Rey Segundo Guerrero-Proenza Joachim Pimiskern

Examples of other esoteric programming languages:

1. Shakespeare: Programs in Shakespeare are written as plays, with characters representing variables and actions representing operations. The language emphasizes readability and aims to resemble Shakespearean plays.

2. Chef: The language is designed to be fun and expressive, but not particularly practical for real-world programming tasks.

3. Whitespace: Programs in Whitespace consist only of spaces, tabs, and line breaks, with all other characters being ignored. This unique syntax makes the language quite challenging to read and write, but it allows for interesting and creative programming techniques.

4. Piet: Programs in Piet are represented as pixelated images, with different colors and shapes representing different instructions. The language relies on visual patterns and requires a special interpreter to execute the programs.

yes, they are programing languages.

Rather than compare natural language to programing languages directly, we should consider ideal semantically and syntactically disambiguated versions of natural language such as artificial languages like Lojban. We should also bear in mind that there are versions of predicate logic which do not employ variables at all, just as natural language does not employ variables. Thus Prolog could be given an alternative syntax without variables. Note also that functional programing largely consists in defining functions. Natural language is used both definitionally and procedurally. For instance we can say: a number is prime if it has no divisors other than 1 and itself. Or we can say: to check if a number is prime consider all numbers less than that number starting at 2. If any of those numbers divides the number then the number is not prime. Otherwise the number is prime.

Today, you can use generative AI like ChatGPT to create programs by human language in any computer language.

In the early eighties I wrote a Basic program on a Wang computer. While I was waiting for the result, I estimated how long the outer loop would take - one year, so I stopped this run. What is easily forgotten in automatic programming systems is complexity theory. You cannot simply throw in a bunch of requirements, rules, axioms, and always expect an automatic programmer to produce code that delivers results within the lifetime of the universe.

Regards,

Joachim

I think Python is closest to the human language.it includes more number of linguistic terms in the syntax. For example, if you mention the starting condition, ending condition ,iterative condition for the loops, it has the syntax for i in range(0,n,2) likewise list ,tuples, dictionary are all used to mention their type of data. In my earlier days, I thought C was the programming language which is closer to human languages ,but now as i told above python is closest to human language

if we consider (1) that not only the flavour of some Programming Languages may be closer to the one of natural languages but also (2) that the semantic scope and precision of their expressivity is broadening, we can be tempted to say that one of the possible ways to process Natural Languages goes through the integration of Programming Language architecture with the one of natural languages.

Compare the linguistic theory of aspect as meta-information (Concern + Aspect) with

Concern

https://en.m.wikipedia.org/wiki/Concern_(computer_science)

Separation of concerns

https://en.wikipedia.org/wiki/Separation_of_concerns

Aspect-oriented programming

https://en.m.wikipedia.org/wiki/Aspect-oriented_programming

Subject-oriented programming

https://en.wikipedia.org/wiki/Subject-oriented_programming

Role-oriented programming

https://en.wikipedia.org/wiki/Role-oriented_programming

Racket: https://racket-lang.org/

Livecode is probably the most “nat. language friendly” programming language.

Just type:

put "Hello World, have a nice day" after the second field of this stack

get the last word of the second field of this stack

if the number of words in the second field of this stack > 3 then

put "----" & it & "----" before the first word of message

end if

And enjoy.

Programming languages are a shortcut to generating machine code. Speech is defined by social convention, so it is context sensitive which is seen as the showstopper. However, having persistent data makes any program context sensitive. The key word here is 'defined' - we can define the social conventions of speech as an arbitrary mapping of an utterance onto a reply (like when someone says "you're welcome" on hearing "thank you").

My research project, Enguage, shows that speech is a Universal Machine, see https://www.bcs.org/articles-opinion-and-research/turing-complete-speech-towards-algorithm-transparency/ - speech is Truing Complete, given the approach of Ordinary Language Philosophy.

In brief, we can view each utterance (the spoken word, the implied thoughts and the reply) as a large positive integer (see Gödel Numbering), and Turing's Universal Machine can be made to work with these large 'numbers' (rather than letters and binary values) to make them act as a functional language.

Moreover, the creation of this software (these arbitrary mappings) can be made by voice (see https://www.youtube.com/shorts/PgodIycEMO4).

The software is free and open source at: https:/bitbucket.org/martinwheatman/enguage

To Joachim Pimiskern: Indeed, since human languages are complex phenomena, their expressions emerged out of much simpler “components”, most probably of large series of numbers, as you (and before you the great philosopher Gottfried Wilhelm Leibniz, 1646-1716) suggested. And, there is no dolby that, to be used by humans as chains of „symbols”, the large series of binary numbers need to be transformed into lists of such „symbols” (≈signs). Those transformations are known as decompilations and result in chains of signs, elements of languages.

It is research on these decompilations that was the subject of my contribution here a few days ago.

Communication in language system devices have their “downwards“ and “upwards”.

Perhaps the idea of 'arbitrary translation' which is at the heart of language understanding (as found in Enguage) can be illustrated if you consider the following? This should read like a specification; however, this are computational instructions written in natural language:

On "what is the fizzbuzz of N":

is N divisible by 5 and 3;

if so, reply "fizzbuzz";

is N divisible by 5;

if so, reply "buzz";

is N divisible by 3;

if so, reply "fizz";

reply "N".

This is a children's game in which you count, replacing numbers in a particular order - 1 2 fizz 4 buzz fizz 7 8 fizz buzz 11 fizz 13 14 fizbuzz and so on. If you are familiar with the issues of trying to use NL as if it were a logical language the 'and' is a conjunction, not a logical AND. Further, there is no syntax - no keywords or reserved words - other than language is a dialectic (the reaction to an utterance is a reply)

This example comes from the file https://bitbucket.org/martinwheatman/enguage/src/develop/etc/dict/f/fizzbuzz.entry which is part of the Enguage test suite.

Clarence Lewis Protin Thus, NL is 'functional', in both senses, in that it both works, and it has a 'call' and returns a value; but it also contains sequential implications of which each is conditionally called. Given that the function calls can be recursive, speech is Turing Complete.

Does this help?

The term 'formal logic' is misleading. I view systems of formal logic as templates for languages in their own right, lacking only a definite assignment of meaning to their primitive terms. Nothing prevents us from gathering together the resources of lexicological resources and formal logic to construct disambiguated versions of (large fragments of) a natural language. This was already a bold proposal of Richard Montague.

https://en.wikipedia.org/wiki/Lojban

Maybe dependent type theory could be used. In this system there is (unlike in simple type theory) no strict demarcation between terms and types. Do the basic rules and constructions of DTT have immediate natural language analogues ?

Thank you, Clarence Lewis Protin, this is thought provoking.

I see your idea that formal logic is used to define a type, rather than suggesting that language, itself, is merely algorithmic. However, my utterance-reply swapping shuns the possibility of formal types: type removes meaning. Saying a word is a 'verb' gives it an unchecked interchangeability between other verbs, and this is not useful, otherwise "loud green flowers sleep furiously", must be meaningful.

Other correspondents have recently mentioned my work may be prefigured by Montague (1974). I still have to look into his work further, but I understand he introduced λ-expressions into the lexicon of tools to describe language types.

I do use λ-expression-like structures when writing, although I attribute this to [Church and] Grice as 'implications' is composite, but mine are simply filled with lists of further 'swaps' and their replies (not logical expressions).

"thank you" => {reply "you're welcome"}

"my name is NAME" => {reply "ok, NAME"}

"i need THING" => {add THING to my needs list; reply "ok, you need THING"}

(where "add THING to my needs list" is supported in another swap.)

However, I always give a name to my λ-expressions, a concrete root, such as "thank you"=>{} above, or "i need".λTHING=>{}, so these are, in fact, functions.

Because each swap has a felicity, a success outcome, and that we can use these λ-expressions recursively, this means that language is functional (formally, Turing complete)

Furthermore, this work is autopoietic: self-supporting:

"to the phrase X reply Y" => {create a sign called X; add the reply Y; reply "ok"}

Moreover, the 'idea of ideas' gives access to your idea of type in that, if the idea of 'need' is already created, you can say "want is like need" which allows the idea of 'want' to take on the shape of 'need'. Maybe, as 'need' defined a shape it is a type, but it is concrete, not abstract.

I expect my disregard for a formal logic is a little disappointing; however, as a good scientist my work is validated by practical experimentation. My language engine, Enguage, has been working for over 10 years. It supports arbitrary swapping, so any language can be supported, even hypothetical ones.

Hope this helps and is of interest.

Still, dear Martin Wheatman , you do not depart from formal logic far enough, not at all. You might ask me why should you? I would reply: No, you should not. Just discover how to build a better (larger, hence more adequate) formal logic. That’s the point.

André Wlodarczyk Thank you for your thought. I think you are right in that any system needs to be demonstrable and repeatable, like a formal logic, otherwise we have a non-deterministic systems, like ChatGPT.

The problem is that formal logic: Boolean, Bayesian, FOPC, λ-Calculus, etc., have always been conveyed on a written medium; however, ideas exist outside of these representations. Speech worked long before these formalisations.

My approach is that speech, itself, must be able to work as a formal logic: it must be demonstrable and repeatable. My felicitous arbitrary swapping of large integers (utterances) does exactly this. This can build a Chinese Room, which supports a conversation without the need for there to be any 'magic' within the system.

Everything is contained within the computation performed (the swapping) with these arbitrary numbers, not within a defined pattern of symbols, +, -, /, x, AND, OR, λ, ), (, and data (variables and constants). It is persuading people that this can be a formal logic is the difficult part. It is possible to represent this swapping in a PL-style syntax:

"thank you"() => {reply "your welcome"}

But this is returning to a written representation (as you say, "[I] do not depart far enough from a formal logic, at all"). Perhaps the only 'proof' can be a speech system that converses, both demonstrably and repeatably?

I hope I have understood your thought correctly.

Martin Wheatman At the moment, I can't work out exactly how your Enguage works, but - for now - I can only expect that at the base of any 'human-centric' (to use your words) intelligent communication system (with speaker/listener) is the triad: calculation categorisation, whatever that means. So I wonder whether you shouldn't go a little further in formalising thought (including abstract reasoning). The exchange of information (in a language) is not just a kind of game since, as I assume, linguistic meaning is aligned with ontology.

My intuition tells me that "speech swapping" (that I understand as the exchange of words) is not very far from 'chatGPT'. But the same intuition prompts me to check out Enguage.

Many thanks for your consideration.

I've just been on my lunchtime walk, and I think I can write a paper outlining a notation. In Turing's universal machine (1936), he uses E-squares (containing High German) and F-squares (containing binary), where the E- (erasable) squares mark F-squares to be processed (something not unlike addresses in a modern solid-state memory - a memory address being a marker for a byte).

Ultimately, these E-squares are ignored/removed in the presentation of his transcendental reciprocals, and the binary can be seen in pictures, such as: https://en.wikipedia.org/wiki/Turing_machine#/media/File:Model_of_a_Turing_machine.jpg

Maybe a notation can be ignored too?

Please consider points A-D below regarding the four facts about language and thought:

(A)

The language utterance says only this:

“The sun is setting and we are still on the road.”

But the language user can understand (either/or, or, and) this:

———

[It's getting late.]

[It's getting dark.]

[We are going to be late.]

[And we were supposed to arrive before dark.]

[Our driver will be sleepy.]

etc …

_____

(B)

Polyglots don't always remember the language in which they learned something, even if they know what they learned.

_____

(C)

Animals also think, although they have no speech faculty.

(D)

The distinction between conscious and subconscious mathematics should be consistent with the general distinction between consciousness and subconsciousness.

In view of such facts, perhaps two Turing machines are needed such that they could be coupled according to circumstances.

Thanks for this. Enguage works as a functional language.

A) And is a conjunction if both halves of the utterance have meaning. So

I need a coffee and I need a biscuit.

is identical to:

I need a coffee. I need a biscuit.

Otherwise it is a conjunction within a list of items, so

I need a coffee and a biscuit.

matches the pattern "i need THESE", and Enguage processes the list like LISP using CAR and CDR operations (conveniently called, 'the first of THESE' and 'the rest of THESE'). So, again, it is identical to the above.

In a dictionary entry for 'the sun', "the sun is setting" will have various connotations (intentions) added. For example:

On "the sun is setting":

it is getting late;

if we were supposed to arrive before dark, reply "we are going to be late";

reply "we are going to arrive after dark".

Similarly, for "we are still on the road" would be part of the concept of being on the road, which will run once "the sun is setting" has been processed. You could issue these utterances the other way around in which case a bit of machine clarification (which Enguage can do) may be in order?

I wrote a paper (2013) on how various ideas interact, and how Enguage can imagine things, using the 'if' 'then' repertoire, which might (or might not!! :) explain in clearer terms? Article A Semiotic Analysis of If we are holding hands, whose hand a...

This covers a similar scenario (of multiple repertoires working together).

B) Enguage is (largely) language independent - it swaps arbitrary strings. It saves used values in the XML format, but this could easily be in JSON or whatever. There are a few configured words, such as the list conjunction "and" to help with matching an utterance to a pattern. But, to my great shame I'm a monoglot! There may be issues when creating dictionaries in other languages, Enguage is not perfect, but there won't be issues over syntax :-)

C) Yes, the main work comes from C. S. Peirce's Semiotics which is multisensory (and multi-species?) Ogden and Richards 1923 book, The Meaning of Meaning, outlines the functional nature of spoken language, and this relates to Peirce's Symbolic (third-level) signs. It could be that, by-and-large, animals don't use Symbolic language, but this is not my area! I was made aware of Peirce's work during my PhD through:Article Towards a Theory of Information: Information: Mystical Fluid...

D) While we can do arithmetic by rote "one plus one" => {reply "two"} It would require an infinite number of sign definitions, an infinite number of times over. I talk about mitigating this in a chapter in a forthcoming book: published by NOVA: Horizons in Computer Science. I pass off arithmetic to a simple traditional parser. This is not of interest to me because this is well understood pattern, and traditional Turing Machines pass arithmetic off to an ALU - some specialised hardware.

No, not two Turing machines, as neither holds intention. This is why you can't write software from some meta-language (such as Z) - someone has to write the Z!

Hope these answers help. I must dash I think I have a paper to write.

It’s nice of you. Your replies make me feel what I understood at the beginning of our views “swapping”.

Either you have a semiotic language or, I even think, rather a noemic code.

Logicians and many computer scientists unconsciously slide from language to code and vice versa.

I wish you departed now from the classical triadic semiotics to the tedradic one.

I have approached this work from a Semiotic perspective since 2002.

I wrote a short paper in 2011 to show how I see the dialectic as a tetrad (there are many versions of this by other authors) Conference Paper A Semiotic Model of Information System

Thus, Enguage not only responds to utterance from a user and builds understanding from utterance from a user, e.g. "to the phrase thank you reply you're welcome" see: https://www.youtube.com/shorts/PgodIycEMO4 ); however, output from Enguage can also be asking for clarification. That implies that a swap is created by Enguage to cover responses, so we may have:

"yes" => {we will be arriving after dark; reply "please check that the driver is not tired"}

A neomic code: my latest chapter, forthcoming deals with machine understanding as the conveyance of ideas to a machine.

Anyway, I'm happy with Enguage because it 'works'; I have a regression test of over 600 utterances (some better than others!) including verbal reasoning and ethical reasoning. But I don't think a dictionary with 600 entries would be counted as sufficient.

Oh, and by the way, did I mentioned that each swap has a 'felicitous' outcome, which is encoded into the reply, such as "okay, ...", "yes, ...." or "sorry, ..." "no, ..." which affect the calling implication. Thus conditional processing is possible.

The source code is in bitbucket.org/martinwheatman/enguage under org/enguage . The tests are under etc/test, and I'm trying to organise the repertoires (etc/rpts) as a dictionary (etc/dict)

Hope this helps.

Just thinking a little further, André Wlodarczyk, you mentioned the issue of 'codes' vs 'language'.

I see codes as having some representative aspect. Codes would be (generally) consecutive values, which represent some 'meaningful' text, for example there might be a 'code' for meaning: 1 = "hello", 2 = "how are you", 3 = "good", 4 = "bad", and so on. Does this make sense? This is not how Enguage works.

Enguage uses non-consecutive text values (utterances) to directly reference one or more intentions (also utterances), each of which are interpreted in turn. In that this works like a functional language, as a Turing Machine, and these utterance values are generated by speech-to-text software, we can perform computational operations (such as building software by implying further utterances) directly by voice.

Does this help?

To Martin Wheatman I'm afraid that our discussion is entering the phase of developing a specific solution to the domain in question. From my point of view, language is also a kind of semiotic code (in the same way as a programming language), because it has its own semantics. For this reason, I distinguish semions from noemata, whose relationship is about alignment (matching, fitting together...), rather than interpretation.

However, as my views on these problems were published only in December 2022, it seems to me premature to impose them to the subscribers of the present discussion in ResearchGate. I propose to continue our discussion outside of this forum because I suspect that your idea of swapping might be an interesting candidate for replacing/better understandig of what I called ‘alignment’ of semiotic (language) codes with ordinary (non-semiotic codes) hoping that you would accept the idea of ‘swapping’ between two kinds of ontology: semiotic and noemic. This is close to the idea of introducing two aligned/swapping (working in parallel) Turing Machines.

In this setting, language would appear to be quasi-autonomous with respect to ordinary knowledge, but - as I could understand - your solution seems to be eminently intra-linguistic.

Yes, I would like to sign off this column as the topic has drifted from the original question. And, I would need to know more about noemata and semions!

To answer the original question, again, I work in utterances (arbitrary strings) which I show to work as a functional language (using the idea of a felicitous outcome, okay?) and this is eminently demonstrable using the software Enguage (bitbucket.org/martinwheatman/enguage)

Thank you!