Omnilow Algorithmic Language Main Description

About

Omnilow is the algorithmic language that is as versatile as natural language. Omnilow is far less ambiguous while still being nearly as efficient (sometimes more) and very easy to learn.

I would suggest reading any complex Omnilow algorithm with Notepad++. A big reason I suggest Notepad++ is because Notepad++ can effectively highlight/indicate parentheticals. That functionality is extremely helpful for reading Omnilow algorithms.

Language is less tedious (for the communicator and the communicatee) as that language is more ambiguous, but being unambiguous is very important for an algorithmic language. How ambiguous communication should be vastly differs based on the situation. Algorithmic language is extremely unambiguous language. Any complex informational framework (that should be communicated in an extremely unambiguous way) should be fully communicated in algorithmic language. In order for an algorithm to fully describe a complex informational framework, it usually must use unorthodox algorithmic operators and algorithmic objects.

Omnilow Rules

1. Each indivisible algorithmic part of an algorithm is (and only can be) an algorithmic object, an algorithmic operator, or an algorithmic variable. Each algorithmic variable acts as (and only can act as) an algorithmic object or an algorithmic operator. Each algorithmic variable is a parenthetical with (and only with) natural-language word(s) or term(s) inside it, or this algorithmic variable is just a single character and acts as an algorithmic object. Each parenthetical in an algorithm acts as (and only can act as) an algorithmic object or an algorithmic operator.
   
   Each natural language word (in an algorithmic variable acting as an algorithmic object) is capitalized or fully uppercase. Each natural language word (in an algorithmic variable acting as an algorithmic operator) is fully lowercase. Each algorithmic operator that isn’t a variable is a one-character mathematical operator. Each algorithmic object that isn’t a variable is a single number.
   
2. Any single algorithm is only a set of algorithmic language (that collectively form a complete statement), and is only one parenthetical (which could have child parentheticals inside it). A single algorithm might be composed of multiple algorithms.
   
3. A bracketed expression using curly brackets is not part of the algorithmic language but is a part of the natural language in the written work. A bracketed expression using square brackets is not a part of the algorithmic or natural language in the written work, and is usually used to indicate a missing part or to provide a note to editor(s).
   • Here’s an Omnilow algorithm as an example.
     (
     (2+2=4)[Change this to something more difficult.]
     
     {If someone has 2 things and then gets another 2 things, then that person now has 4 things.}
     
     (5+5=[Insert the answer.])
     
     (((Answer)(to)(Ultimate Question Of Life))=42)
     
     {An algorithm equating to the “(Ultimate Question Of Life)” variable has not yet been made.}
     )
     
4. Algorithmic objects being next to each other represents (and only represents) the “(and)” algorithmic operation between each of these algorithmic objects. An algorithmic operator being next to an algorithmic operator (or a algorithmic object) represents (and only represents) the “(and)” algorithmic operation between each of these 2 algorithmic parts (if each of these algorithmic parts wouldn’t cause an external action to the other algorithmic part).
   • I don’t think two numbers/variables being next to each other should represent multiplication or any other algorithmic operation (other than “and”).
     
5. Each algorithm (that is in written form) is only a string of characters, and any potential rich text attribute doesn’t have any algorithmic significance. Omnilow algorithmic language is supposed to be written in just plain text. Each part (of an algorithm in written form) does not contort any writing in that algorithm. Any algorithmic operator must not contort the writing of algorithmic objects. A missing algorithmic object must not represent a specific number.
   • For example, the square root of 25 should be written as “2√25”. It must not be written as , , or “√25”. That root character must not be extended into the area that that “25” is written, and that “2” must be present and must not be written any smaller nor in the area of that root character.
     
6. An algorithmic object (that is a type of thing and isn’t specified as some specific ones of that type of thing) is equal to any specific ones of that type of thing. In other words, algorithms referring to any specific type of thing applies to everything of that same type. Because, that specific instance could be any of those instances since it isn’t specified, so the only way to make that algorithm true is if it applies to each of those instances and not just an individual instance. An algorithmic object (that is a type of thing that is quantifiable as a numerical value but its quantity isn’t specified) is equal to 1 of those. Those are rules in order to make this language more efficient to write/read.
   • Here’s an Omnilow algorithm as a demonstration.
     (
     ((Apple)=(((any)(specific))(Apple)))
     
     ((Apple)=(1(Apple)))
     
     {Those above algorithms would be implied for the algorithm below (and so wouldn’t be present if this wasn’t just a demonstration). “(Apple)” by itself would be assumed to be referring to any specific single apple.}
     
     ((Apple)(is)(Red))
     
     {The above algorithm basically only means that each apple in existence is red.}
     )

Additional

Problems With Mainstream Algorithmic Language

Omnilow uses mathematical variables differently than almost all major scientific algorithms. I don't think that an algorithm should use a variable as a single letter (unless it is a specific fundamental mathematical number or it is a placeholder for an input and/or output of any algorithm). I think all other variables should be natural language word(s). Mathematical operators are more fundamental in algorithmic language so I think they should be represented by a single symbol until there are no more undesignated popular symbols to use.

If the natural language (of an algorithmic variable) has any spaces or dashes, I think this variable should be a parenthetical. There is a formatting rule (in the Omnilow Rules section) that each algorithmic variable is suppose to be a parenthetical (unless it is just a single character), but I think that rule could be violated (for variables without spaces or dashes in it) in less formal situations if the readers would not be confused by it.

Mathematically fundamental numbers include π (the ratio of a circle's circumference to its diameter), i (the imaginary number), and e (Euler's number). Single letter variables (for a placeholder for an input and/or output variable) that are commonly used include n (some specific number), l (length), w (width), h (height), t (time), and x, y, and z (coordinates).

I think scientific variables (that are meaningless in pure mathematics) should never be a single letter because they are a part of science and not mathematics. Mass, electric charge, velocity, speed, and acceleration are usually written as a single letter. At least for English readers, I think these variables should be written as "(Mass)", "(Electric Charge)", "(Velocity)", "(Speed)", and "(Acceleration)".

Learning scientific algorithms is much more difficult than it needs to be because one has to understand what many weird letters represent in some particular algorithm (which likely involves understanding what other weird letters represent in sub-algorithms). It's also more difficult because some of these letters look alike which means that great vision is often needed to understand these overly-convoluted variables.

I think this popularity for one letter variables is partially because two numbers/variables being next to each other represents multiplication in very many modern algorithms/formulas. Financial algorithms are easier to learn than equally complex science algorithms because understanding what weird letters represent is less important in financial algorithms.

It is very common for two numbers/variables next to each other to represent multiplication in math. It is very common for a root symbol with no number to the left to represent a square root in math. Many mathematical operators use mathematical operators that contort the numbers/variables that use them. I think those are bad practices. A root and division/fractions are some of the most popular examples of mathematical operators contorting numbers. The main reasons I don't think there should be contortion is because plain computer text doesn't allow for that and there are benefits to each line of text having the same height. I think it would be reasonable enough otherwise.

Algorithmic VS Mathematical VS Computer Language

Mathematical language is a subset of algorithmic language. Mathematical language is algorithmic language that fulfills some additional requirements. For some people's definition of mathematical language, some of these additional requirements would require that only more-simple algorithmic objects and more-simple algorithmic operators be used in mathematical language.

I would define mathematical language as any language that is algorithmic (and doesn't allow for any potential paradoxes with usage of this language) (and doesn't have overly ambiguous rules and/or axioms). All the rules/axioms (for preventing any potential paradoxes with usage of that language) must not be overly ambiguous (for that language to qualify as a mathematical language in my definition). Many algorithmic languages have overly ambiguous rules/axioms for preventing that (which means that language isn't a mathematical language).

If English used parentheticals to fully-accurately group words together, English would be an algorithmic language, but it wouldn't be a mathematical language.

A computer language (AKA programming language) is an algorithmic language that is absolutely unambiguous for a computer to execute on. A basic computer without any AI can execute algorithms written in a computer language.

Omnilow is far too ambiguous to ever qualify as a computer language, but anything written in a computer language (or any other language) could still be translated into Omnilow and visa versa. A compatible Omnilow algorithm could even be perfectly translated into a computer language algorithm/program if its Omnilow variables were strictly defined beforehand. But, computer language should still be used over Omnilow in most scenarios.

There is nothing that Omnilow can't do that a natural, algorithmic, mathematical, or computer language can do.

Other

I, Samuel Sauer, am the creator of the Omnilow algorithmic language. I created and wrote this post and created all the significant concepts in this post.

I would generally recommend not having a braced expression using curly braces on the same line as any algorithmic language. If you use Notepad++ for Omnilow algorithms, I would suggest having "Word wrap" turned on, and having "Light mode" turned on (in the Settings\"Preferences..."\Dark Mode page) along with having some other settings to make reading Omnilow algorithms easier in Notepad++.

Each variable in a Omnilow algorithm should be complete and fully detailed in natural language, Omnilow algorithmic language, or a mixture of those languages. If that written work is intended for most any reader, most anyone that knows the natural language and knows those Omnilow rules (in the Omnilow Rules section) and has at least moderate mathematical knowledge should be able to fully understand every algorithm in that written work without needing to learn anything else.

I named it the "Omnilow" algorithmic language because it is very versatile (there is nothing that Omnilow can't do that another algorithmic language can do) and it has a low cognitive barrier to entry (it's simplistic). Please leave a comment or reach out if you have incorporated Omnilow algorithmic language into your problem solving toolkit; I'd be curious to know. I think Omnilow can be very effective for analyzing "Complex Problems".

Next Posts To Read

My Meta Omnilow Algorithms post has very relevant content to better understand the Omnilow algorithmic language and algorithmic language in general. I would suggest reading it next after reading this post.

I would recommend reading my Algorithmic Proof That You Should Rush post as it showcases how useful Omnilow algorithmic language can be for solving real-world "Complex Problems".