If I eat myself will I get twice as big or disappear completely?

Make a language with the exact same syntax as ENGLISH. For example:

"This is a comment."

Create a new variable named answer.
Have the variable named answer store the value of 10.

"Don't forget, grammar and spelling matter!"

If the variable answer is equal to 10, then do the following:
  1. Add a value of 5 to the variable.
  2. Create a new variable named question.
Otherwise, do the following:
  1. Exit the function.

Now, you can say that you're favourite language is English!

I have no ideas, I am lazy.

I present...

Cxx

A static language that is weakly typed with implicit type coercion no matter what you do. For example:

int number = 5;
Console.Log(typeof number);

Your output will be:

<= Array[5]: [ Number, String, Boolean, Array, Null ]

Now, imagine you have another number:

int number2 = 10;

Adding them together gives:

<= "105"

Due to type coercion. Also, the same thing does not happen to strings:

String number1 = "5";
String number2 = "10";
Console.Log(number1 + number2);

<= Error: Cannot add two arrays

Due to strings being converted into Arrays.

Because of type coercion, this is logic:

5 == "100" => true // (both can be converted into booleans of true)
0 == 0 => false // (0 is not the same as false)
2 == 1 => true // (2 = true = 1)
"string" == "string" => false // (they have become arrays and require a deep equal in order to be true)
"5" == "2" => false // (same problem as above)
(Char)"5" == (Char)"2" => true // (both have become booleans due to explicit type)

Due to the nature of RegExp, RegExp has not been considered a type. It is considered a substance. A substance is that of a type, but it cannot be coerced for it is too pure. Substances are similar to classes, but they are not.

Substance.RegExp myRe = (new)Substance.RegExp(@"[^\d][\d\w]+"gi);
Console.Log(typeof myRe); => Substance.RegExp

Equalities with substances do not give you sane answers.

Substance.RegExp myRe = (new)Substance.RegExp(@"[^\d][\d\w]+"gi);
Substance.RegExp myRe2 = (new)Substance.RegExp(@".+"gi);
myRe == myRe2 => How Dare you Even Try To Compare Substances! Do you even know THE tRue Po𝑤͙͎̔̈́͠𝑒̦͔̙̓̓͌𝑟̡̫͌͑͘͜ o̸͖͚̓͆͠͝f̴̨̡̢̜͙̣̗͎̗̮̤̮̞̘̻͆̄̾̾͑̅͋͋̋͠ͅ ̶̧̧̡̱̳͔̙̬͈͈͍̗̊̌̊͌͑̓̍́̃͝s̴̢̨̞̩̱͈̙̥͖͎͖̭̣̠̓̔̔͊́̊̌̈̄̽̽̇̓͌͐͜͝ͅu̷̡̡̳̻̣̟͍̥͍͉̤̦̟̫͓̖͑̀̏͒̓͛̉̓̂̇ç̸̛͖̖̘̠̲̫̜̮̭̫͎̭͚̻̯̘̌͆̆̑͌̑̃̍̈́͒͊͘̕̚̚͝h̸̢̨̡̤̯͎͓̞͍͇̖̖̼̝͆̀̓̀̋͛̑̚ ̵̭̺̲̻̳͓͇̲͛̒̈̔̀̋̓̂̓̾̐͆͒̂͝͝t̸̞̩͙̖̞̱̭̟̭̮͉̲̠̊̑̀̌̋͆̄͂̑͑́͜͠h̵͉̰͆̔̊̐̈́͂̃̄̑̃̋̊͛͂͌ï̴̢̧͍̳͍̅̈́͛̑̓͗̿̒͌̿͛̒̄̚͠ṇ̵̢̾̊̄̈̏̎̍͐̅̌̔̀̕͝g̸̡̻̟̭͇̤͓͙͕̫̿̋͗͑͗̃̄̈́͝s̶̤͕̻̼̣͓̻̤̫͇̥̱̮͖͕̳̆̉̿̅̋̋͛̐̽͘͜ ̸̝̓̿́̎̓͘ỵ̵̨̧̯͍̱̫̲̘̩̘̏͋͑o̶̡̲̥͙̣̥̝̰̣͗͐̂͗̄̓̈́͜ű̵̠͐̓̋̓͐̊̃̿̚͠ ̵͓͉̕s̷̡̖̭̥̫̼̥̒̇͋́̏̀̚m̷͇͈̗͚̗͉̩̖̹͍͉͖͔̼̅̍̓̑̈̋̃͛͛̕a̵͚̣̯̫̮̬̞͚̙͎̹̋̈́̅̄̐͒̋̈́̇́̚͝ḽ̸̗̬͍̫̣̠̿̓͆l̷͖͕̣̳͉͙͇̀͋͒͋̊̉̄̅̀͝͠ ̴̡̡̛̻̟̖͍̘̃̈͐͛̌́͂͂́̑̃͌̆̋̽̚b̸͇̭̦̬̝͔̈́͂̊͌̿ȑ̷̨͉̱̬̮̩͉̘͎̩̩̙͓͙̊̈́́͊̿̾͠à̸̡̳̝̫̘̯͙͚͎̺̋͛̔̔͒̐͆͌̈́̕i̸̜͆̿̈́͑͌̏̂̑̾̈̎͝n̵̢͚̥͈̰͚̐̐̅́̌̉̃͆͛̈́̃̇ ̸̤̲̲͕̘͇̞͔́͊̃͐͑̅̿̓̾̊̈́̕̕͜p̵̡̖̖̙̝̬̪͈̙̖͓̙͚͛r̴̛͔̳̺̺̪̓͒̈́̄̈́͌̔̑̿̏̕ȍ̸̢̠̖̩̫͕͔̣̘͕̳̽̏̾̈̆̔́̈̄͘͘ͅģ̸̛͇̿̐͗̾͂̆̀̈́̌̋̋̍̑̈́͠ř̶͈͚̥̱͚̹͉͙̯̞͓̬̑̕à̷̰̲͕̯͇͓̖͉͚̒̉͜ͅm̶̨̦̰̱̪̤̻̯̙̔͆̈́͐́̚͝m̵̡͔̰͇͓̮̣̱̞̜̥̣̤̂͜e̶̛̠̝͉r̵̢̧̛̹͎̜̘͙̻̫̙̦̻̜̟͕̱͑̃̍͌̈́̃̓͊̿̕͜

Funnily enough, no errors are thrown.

Now, to define a function, you do:

void FunctionName(int arg1, int arg2) {
  return arg1+arg2;
}

Of course, a return value is not required. Return values follow the same implicit type coercion.

Surprisingly, you can convert functions into Substances:

void FunctionName(int arg1, int arg2) {
  // Code
}
(Substance.Generic)SubtanceFunction = FunctionName;

However, the function has become a substance, but the code does not. This means, comparing it to other Substances will give you the same result as the RegExp had:

void Function1(int arg1, int arg2) {
  // Code
}
void Function2(int arg1, int arg2) {
  // Code
}

(Substance.Generic)SubstanceFunction = Function1;
(Substance.Generic)SubstanceFunction2 = Function2;

SubstanceFunction = SubtanceFunction2 => How Dare you Even Try To Compare Substances! Do you even know THE tRue Po𝑤͙͎̔̈́͠𝑒̦͔̙̓̓͌𝑟̡̫͌͑͘͜ o̸͖͚̓͆͠͝f̴̨̡̢̜͙̣̗͎̗̮̤̮̞̘̻͆̄̾̾͑̅͋͋̋͠ͅ ̶̧̧̡̱̳͔̙̬͈͈͍̗̊̌̊͌͑̓̍́̃͝s̴̢̨̞̩̱͈̙̥͖͎͖̭̣̠̓̔̔͊́̊̌̈̄̽̽̇̓͌͐͜͝ͅu̷̡̡̳̻̣̟͍̥͍͉̤̦̟̫͓̖͑̀̏͒̓͛̉̓̂̇ç̸̛͖̖̘̠̲̫̜̮̭̫͎̭͚̻̯̘̌͆̆̑͌̑̃̍̈́͒͊͘̕̚̚͝h̸̢̨̡̤̯͎͓̞͍͇̖̖̼̝͆̀̓̀̋͛̑̚ ̵̭̺̲̻̳͓͇̲͛̒̈̔̀̋̓̂̓̾̐͆͒̂͝͝t̸̞̩͙̖̞̱̭̟̭̮͉̲̠̊̑̀̌̋͆̄͂̑͑́͜͠h̵͉̰͆̔̊̐̈́͂̃̄̑̃̋̊͛͂͌ï̴̢̧͍̳͍̅̈́͛̑̓͗̿̒͌̿͛̒̄̚͠ṇ̵̢̾̊̄̈̏̎̍͐̅̌̔̀̕͝g̸̡̻̟̭͇̤͓͙͕̫̿̋͗͑͗̃̄̈́͝s̶̤͕̻̼̣͓̻̤̫͇̥̱̮͖͕̳̆̉̿̅̋̋͛̐̽͘͜ ̸̝̓̿́̎̓͘ỵ̵̨̧̯͍̱̫̲̘̩̘̏͋͑o̶̡̲̥͙̣̥̝̰̣͗͐̂͗̄̓̈́͜ű̵̠͐̓̋̓͐̊̃̿̚͠ ̵͓͉̕s̷̡̖̭̥̫̼̥̒̇͋́̏̀̚m̷͇͈̗͚̗͉̩̖̹͍͉͖͔̼̅̍̓̑̈̋̃͛͛̕a̵͚̣̯̫̮̬̞͚̙͎̹̋̈́̅̄̐͒̋̈́̇́̚͝ḽ̸̗̬͍̫̣̠̿̓͆l̷͖͕̣̳͉͙͇̀͋͒͋̊̉̄̅̀͝͠ ̴̡̡̛̻̟̖͍̘̃̈͐͛̌́͂͂́̑̃͌̆̋̽̚b̸͇̭̦̬̝͔̈́͂̊͌̿ȑ̷̨͉̱̬̮̩͉̘͎̩̩̙͓͙̊̈́́͊̿̾͠à̸̡̳̝̫̘̯͙͚͎̺̋͛̔̔͒̐͆͌̈́̕i̸̜͆̿̈́͑͌̏̂̑̾̈̎͝n̵̢͚̥͈̰͚̐̐̅́̌̉̃͆͛̈́̃̇ ̸̤̲̲͕̘͇̞͔́͊̃͐͑̅̿̓̾̊̈́̕̕͜p̵̡̖̖̙̝̬̪͈̙̖͓̙͚͛r̴̛͔̳̺̺̪̓͒̈́̄̈́͌̔̑̿̏̕ȍ̸̢̠̖̩̫͕͔̣̘͕̳̽̏̾̈̆̔́̈̄͘͘ͅģ̸̛͇̿̐͗̾͂̆̀̈́̌̋̋̍̑̈́͠ř̶͈͚̥̱͚̹͉͙̯̞͓̬̑̕à̷̰̲͕̯͇͓̖͉͚̒̉͜ͅm̶̨̦̰̱̪̤̻̯̙̔͆̈́͐́̚͝m̵̡͔̰͇͓̮̣̱̞̜̥̣̤̂͜e̶̛̠̝͉r̵̢̧̛̹͎̜̘͙̻̫̙̦̻̜̟͕̱͑̃̍͌̈́̃̓͊̿̕͜

Finally, if you try to compare a normal function to a substance function, you get:

void NormalFunc(int arg1, int arg2) {
  // Code
}

(Substance.Generic)SubstanceFunc = NormalFunc;

SubstanceFunc == NormalFunc => 1

1 is the result you will get no matter what is being compared to any substance.

And that is all for this language! Rumors are that JavaScript is written on top of Cxx.

I've been thinking about making a language entirely in Spanish, so you could end up with something like this:

público entero[] x = [1, 2, 7, 3]
por-cada i en x {
  poner(i)
}

I present to you my truly innovative language: Singularity

You are only allowed one variable per script and it must be Elon_Musk

All functions can only return values in binary

When the script ends the program will automatically print the number 3 trending result on Google Trends

Your output will be emailed to you within 8-10 business days during which time we convert your program your program into punch cards.

All errors are returned to you with a snarky comment about your hygiene

All while loops are infinite no matter what you do

The documentation is written in Ancient Sanskrit and all attempts of trying to translate it have resulted in mildly unsuccessful careers, Although we do provide a good Dental plan

I present to you my truly innovative language:

???

Code will only compile and run when the programmer has died. Therefore, no one really knows the syntax of this language because we don't know how to raise people from the dead, yet...

The chicken

for x in chicken:
  print("no")

Is translated in chicken to:

chickenchickenchicken chicken chickenchicken chickenchickenchickenchickenchicken:
  chicken("chickenchicken")

a language that runs a completely randomly generated program, and once it's done you give it an emoticon to express how happy you were with the program, and eventually you can train it to run the program you want.

My wildest programming language ideas are

Objective BASIC

Like an object-oriented version of BASIC. (might actually make)

Adapt

A programming language where you can dynamically change the syntax with the ability to rewrite the program while it is running and variables with multiple types simultaneously. (in development)

XPL

A language based on XML (https://github.com/amazingmech2418/xpl)

Link

A language based on JSON that could allow programming via a flowchart. (https://github.com/AmazingMech2418/Link-Programming-Language)

Inventor

A language which is entirely based on transpiling. (https://github.com/AmazingMech2418/Inventor)

Possibly the worst programming language I have made actually. LOL!

X

A C-style language with a full graphics library, a safe memory system without buffer overflows, with prototypal OOP, and with a powerful mathematics library. (in planning stage currently)

A language that throws errors no matter what you add
AKA: no correct syntax

P programming language that is only ONE character (basically reads your mind)
and the character is 1 so binary but one instead of two.

SplatLang - A Splatoon themed programming language

sorry for terrible joke that could have come from sans himself

Basics:

• file extension: .splat
• as much esolang as useful
• splatoon themed syntax (you could have guessed)
• safe like C#
• a few good data types
• a built in help method
• and more!

Woomy - Print method

The method for printing something to the console is woomy(). This is a sample of using woomy():

Input:

woomy("Hello, Inkopolis!")
// this is a single line comment comment
/^ this is a squid comment.
goes over multiple lines.
named that because the ^s look kinda like squids.
will end with:
^/

Output:

Hello, Inkopolis!

Veemo - Builtin slowprint method.

veemo() will print something to the console, but wait in between each character printed.

A value for how much time to wait is measured in milliseconds

Input:

veemo("Hello, octo valley!", 60)

Output (with 0.06 seconds in between characters:

Hello, octo valley!

Getting input

The method for input is playAnotherBattle() with the prompt inside the ()s. If you put in nothing, then the prompt will automatically be >>.

Input:

playAnotherBattle("Will you rescue the Great Zapfish?\n>> ")

Output:

Will you rescue the Great Zapfish?
>> (halts until enter key is pressed)

Data Types

SplatLang supports nine data types, most of which are pretty much the same as some Java data types.
Integral:

• byte - A 1 byte integral value
• short - A 2-byte integral value
• int - A 4-byte integral value
• long - An 8-byte integral value
  Float-point:
• float - A 4-byte float-point value
• double - An 8-byte float-point value
  Characters:
• char - A single ASCII/Unicode character surrounded by two 's
• string - A sequence of ASCII/Unicode characters surrounded by two "s
  Other:
• bool A boolean value. SplatLang boolean values are:
  • fresh - equivalent to true in other languages
  • unfresh - equivalent to false in other languages
• void - No specific type, can be any other type

Variables, Constants, and Lists

Look at the code below (java syntax highlighting (not java code) ):

// integral (variable)
byte thisIsSoShort = 100
short aLittleLonger = 10000
int medium = 1000000000 
long lengthy = 1000000000000000
// float point (list)
float shortFloat[] = {1.11111111, 300.12345, 0.0123}
double longFloat[] = {1.11111111111111, 56633.22134552444}
// characters (constant)
con char delta = 'Δ'
con string message = "SPLATLANG IS AWESOME!!!!"
// other
con bool djOctavo = unfresh
void thingsThatAreCool[] = {120, 10010, 2000000001, 14367424553, 6.54321, 3.13432444246543, 'Ω', "YEET!", fresh} 

That shows variables, lists, and constants in one program.

Operators

Here are the operators:

// basic math
+ // addition
- // subtraction
* // multiplication
/ // division
% // return remainder
// quick basic operations
+= // increase by certain amount
-= // decrease by certain amount
*= // multiply by certain amount
/= // divide by certain amount
%= // divide by certain amount but return remainder
++ // increment by 1
-- // decrement by 1
//comparing
== // equal to
!= // not equal to
< // less than
<= // less than or equal to
> // greater than
>= // greater than or equal to
// boolean logic
&& // and
|| // or
! // not

Conditionals

The conditionals are if, also, and othersUnfresh.

int nklings = 1000
int octolings = 750

if ^inklings == 1001^/^ unfresh ^/ {
    woomy("1001 inkings in inkopolis\n")
}
also ^inklings == 1000 && octolings == 1000^/^ unfresh ^/ {
    woomy("Inkling and octoling numbers equal, they are" + inklings + "\n")
}
othersUnfresh/^ this will run since the others are unfresh ^/ {
    woomy("Unknown.\n")

Loops

And finally, there are loops. There are while, for, and forAllSquids.

// example 1:
while ^fresh^ {
    // infinite loop
    woomy("Booyah!");
}
// example 2:
bool isItFresh = fresh

while ^isItFresh == fresh^ {
    woomy("I WILL ALWAYS BE FRESH!!!")
}
// example 3:
for ^i = 0; i < 6; i++^ {
    woomy(i)
}
// example 4:
aRandomList = {"oof", "yeet", "kobe}"
forAllSquids ^string item in aRandomList^ {
    woomy(item)
}

THAT"S IT!!!

bye remind me of typos and stuff

Make a programming language that is made completely of emojis. Example code:

😀😁😂😃😎😋😃☺😚😃😘🙂😘😍😶😎🤨🤗😋😘😎🥰😨😦🥶😱😨🤯😳🤯🥵🥵🥵😷🤕😡🥺
      😫😫🙂😎😣

Harry Potter would be nice:
Lumos
Aparecium “Hello World”
name=Veritaserum.reveal(“What is your name”)
Aparecium “Hello”+name
Avada_Kedavra

Some sort of language a bit like LOLCODE. example:

sey: 'hello world' plz
make 'variable1' into 'variable1name' plz
repeat [say: 'hello world'] 10 times plz
name iz respond: 'what is ur name' plz
wut if name iz 'MemeMan':
    sey: 'hi meme man :P'
    if no 'MemeMan': sey: 'hai stranjer' plz

So sey is kinda like print in Python, plz is kinda like ; in JavaScript, respond is like input in python, iz is like =, wut if is like if, if no is like else, and make is like var.
I spent too long thinking about this :)

TortureLang: more annoying than brainf***

basics

• File extension: .tl.
• must have as many semicolons as there are other characters on line
• you cannot have whitespace before actual code.
• no way to comment
• just says boo, you suck! when there's an error
  worse:
• processes 4 lines in one second.
• can only process 32 lines of code.
  worst:
• you have to wait an hour before output

syntax

Print syntax:

you must write the string on as many new lines as there are characters in string to print each character

1   Writethislineinconsole "Hello world!";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   Hello world!;;;;;;;;;;;;
3   Hello world!;;;;;;;;;;;;
4   Hello world!;;;;;;;;;;;;
5   Hello world!;;;;;;;;;;;;
6   Hello world!;;;;;;;;;;;;
7   Hello world!;;;;;;;;;;;;
8   Hello world!;;;;;;;;;;;;
9   Hello world!;;;;;;;;;;;;
10  Hello world!;;;;;;;;;;;;
11  Hello world!;;;;;;;;;;;;
12  Hello world!;;;;;;;;;;;;
13  Hello world!;;;;;;;;;;;;

Will Supposed to output:

Hello world!

Capture input, variable, and if statement syntax:

there are only three available variable names and here they are:

• VaRiAbLe01
• MYSecoNdvarIABle
• ThIsistHEthiRdaNDlaSTVariabLe
  Also, this is the variable assigning sequence, =-_-__=_=
  For if statements, the entire output is in braces ({}) and you can only have one in the entire program
  Example:

1   variable VaRiAbLe01 =-_-__=_= captureuserinput ">> ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   if VaRiAbLe01 = "Joemama" {;;;;;;;;;;;;;;;;;;;;;;;;;
3   Writethislineinconsole "is fat"{;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4   is fat;;;;;;
5   is fat;;;;;;
6   is fat;;;;;;
7   is fat;;;;;;
8   is fat;;;;;;
9   is fat};;;;;;;
10  };

Else syntax:

Elses work the same way ifs do
Same example with else statement:

1   variable VaRiAbLe01 =-_-__=_= captureuserinput ">> ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   if VaRiAbLe01 = "Joemama" {;;;;;;;;;;;;;;;;;;;;;;;;;
3   Writethislineinconsole "is fat";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4   is fat;;;;;;
5   is fat;;;;;;
6   is fat;;;;;;
7   is fat;;;;;;
8   is fat;;;;;;
9   is fat;;;;;;
10  };
11  else{;;;;;
12  Writethislineinconsole "shut up";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
13  shut up;;;;;;;
16  shut up;;;;;;;
17  shut up;;;;;;;
18  shut up;;;;;;;
19  shut up;;;;;;;
20  shut up;;;;;;;
21  shut up;;;;;;;
22  };

That's about it Here's a sample program:

1   variable VaRiBbLe01 =-_-__=_= 10;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2   variable MYSecoNdvarIABle =-_-__=_= captureuserinput "like it? >> ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
3   if MYSecoNdvarIABle =-_-__=_= "yes" {;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
4   Writethislineinconsole "u are evil";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
5   u are evil;;;;;;;;;;
6   u are evil;;;;;;;;;;
7   u are evil;;;;;;;;;;
8   u are evil;;;;;;;;;;
9   u are evil;;;;;;;;;;
10  u are evil;;;;;;;;;;
11  u are evil;;;;;;;;;;
12  u are evil;;;;;;;;;;
13  u are evil;;;;;;;;;;
14  u are evil;;;;;;;;;;
15  };
16  else{;;;;;
17  Writethislineinconsole "you are so right";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
18  you are so right;;;;;;;;;;;;;;;;
19  you are so right;;;;;;;;;;;;;;;;
20  you are so right;;;;;;;;;;;;;;;;
21  you are so right;;;;;;;;;;;;;;;;
22  you are so right;;;;;;;;;;;;;;;;
23  you are so right;;;;;;;;;;;;;;;;
24  you are so right;;;;;;;;;;;;;;;;
25  you are so right;;;;;;;;;;;;;;;;
26  you are so right;;;;;;;;;;;;;;;;
27  you are so right;;;;;;;;;;;;;;;;
28  you are so right;;;;;;;;;;;;;;;;
29  you are so right;;;;;;;;;;;;;;;;
30  you are so right;;;;;;;;;;;;;;;;
31  you are so right;;;;;;;;;;;;;;;;
32  you are so right;;;;;;;;;;;;;;;;
33  you are so right;;;;;;;;;;;;;;;;
34  }

Supposed to output this thing:
like it? >> {enter your choice here}
If you choose yes, it will output the following:
u are evil
If you type anything else, it will output:
you are so righ
The last character was not printed since the computer will ignore anything beyond the 32-line limit.
This is why TortureLang sucks!

HahaYes

Something where the syntax changes based on the previous commands. No program has the same rules. Or you can only use each syntax construct x times.

5 for loops, 10 ifs...

Oh! I thought of another equally silly one! Make a language called "le twatter". For example:

tweet "Hello World!\n"
receive tweet "What is your name? "

post Animal:
  public comment legs
  public comment colour
  
  story(_legs, _colour):
    legs = _legs
    colour = _colour

  reply DisplayInfo:
    tweet "This animal has " + legs + " legs"

account.end

One language to rule them all.

It will be basically a combination Swift, Go, Lua, and D.

It will have a massive standard library suitable for many projects.

It will have documentation comments via a subset of Markdown.

It will be compiled to efficient bytecode for portability.

The bytecode intepreter will be fast and efficient.

It will have support for both low level and high level programs.

It will be object oriented.

The programs will be class based.

It can have built-in functions equivalent to assembly instructions, to reduce the need for pure assembly.

And most importantly...

Readable syntax.

There's always a relevant xkcd

OHHH! you should do a mix of evry language here on repl! # A header

code here

#code here

a mix of code syntaxes that make a game or whatever..

Java script

Dictionary oriented programming. Instead of using classes and objects, use an abstract dictionary as a struct. Then you can add functions to the dictionary to make the structs into classes. (Not sure if this has been made.)

A language where you can create your own loops
like

 loop repeatUntil {
   if condition {
     stop
   }else {
     run
   }
}

The condition keyword is the condition that is put into the loop, the stop keyword tells the loop to break, and the run keyword runs the code you put in your loop. Also the loop keyword is for defining loops and after that in this example, repeatuntil, is the name of your loop.

what if you make loops so long and so complicated, that everyone would think you were a coding genius if you did one in under 10 seconds. i.e

ifora (splitseconde33over4pi)(onyyx3302_o5){i++[if chicken is the best
ch1cken will post]++i}

this prints
if chicken is cool,
ch1cken will post this,
2 times.

A language called hack(not for hacking, just a cool name). Dunno how to describe it but the hello world program would look like this: go {hwor}(built-in variable hwor is 'hello world'
Outputs 'hello world'

Make a function:

new func(series;;argument1;mode;;) {
  if:mode = 'positive' {
    new int(a) { math.add(argument1, 1) }
    new int(b) { math.mult(a, 2) }
    new int(c) { math.add(b, 3) }
    represent c
  }
  else if:mode = 'negative' {
    new int(a) { math.sub(argument1, 1) }
    new int(b) { math.div(a, 2) }
    new int(c) { math.sub(b, 3) }
    represent c
  }
}

Ask me anything I'll give u the hack syntax

In one line: extending Lisp to the 4th dimension.

(apologies for the lengthy post, but I would really appreciate some feedback)

Rome: A thesis for Lisp in the 4th dimension, with fewer parenthesis

Introduction

In the course of it's development, the LISP system went through several stages of simplification and eventually came to be based on a scheme for representing the partial recursive functions of a certain class of symbolic expressions...and it now seems expedient to expound the system by starting with the class of expressions called S-expressions.

-- John McCarthy in the seminal paper that introduced Lisp to the world in April 1960.

Also, from the paper:

An S-expression is then simply an ordered pair, the terms of which may be atomic symbols or simpler S-expressions.

This statement can be expressed symbolically as:

S := (S . S)

Any of the S on the right hand side can either be a terminal symbol that cannot be further expanded called an atom or it be expanded recursively in the same manner, as another (S. S).

Turtles all the way down.

The whole of Lisp is built up from this scheme of S-expressions.

Hmm....So an S-expression is simply an ordered pair (yes, and recursive...)

But why a pair? (Reminds me of Key-Value pair).

Why not three? (Like you know: Key, Relation, Value, like in RDF triplets? )

You know what, better stil...Why not four?

4-tuples. Key, relation, value + time? (like in Datomic clojure DB and datalog etc).

O-expressions

What if, instead of S-expressions, we start with ....say O-expressions

O := (O . O . O . O)

Where each O can be:

• expanded further as (O . O . O .O)
• or it can be a terminal symbol.
• an S expression (maybe I am not sure about this).

Will we end up with a Lisp like language that's somehow more expressive?
In the same manner, RDF triplets are more expressive than key-value pairs.

Will we be able to programmatically play with time?

Like how including time in the 4-tuple gives datomic time travelling capabilities?

Well, we will find out I guess....

What's in a name

For fun and for clarity, I am using the uppercase greek symbol of Omicron to represent the O in the O-expression.

And I came up with a fun acronym too:

ROME stands for Recursive Omicron Meta Evaluator (ha!) This is the name of the compiler/translator itself.

and the language itself to be called:

Roman: Recursive Omicron Meta Algebraic Notation. (ha ha!).

(In the long tradition of functional languages, everything will be an Expression in Rome, no statements vs expressions dilemmas.

Please...can we at least not have as many parenthesis?

What if we express function composition as:

x f g to mean the same as (g(f(x)))

Look ma! fewer parenthesis.

Lisp uses prefix notation

(add a b)

where a and b are the arguments to the function.

Let's go ahead and use this format for function calls

a b add

Also we need one last thing. Take a leaf out of Elixir/ELM/ReasonML pipe operator. |> We will be using this too in our approach to have fewer parentheses.

Examples of how Rome might look:

Assign 5 to a.

a = 5 def

Check if a is greather than b

a > b ?

Let it be a fact that the symbol a is greather than b.

a > b def

Nested expressions

(11 19 *) < (9 23 *) ? 

or

  11 19 *
, <
, 9 23 *
, ?

assign it to. value

a = (11 19 *, 9 23 *, +) def

Define a function to add 3 to any number

add3 (a) (a 3 +) fn

or using the lambda method (=> stands in for lambda)

add3 = ((a) (a 3 +) =>) def

Yeah you can't get rid of all the brackets I think.

Function calls:

4 add3 .

with assigns

a = 4 add3

Find b.

  b > a def
, b < c def 
, a = 1 def
, c = 3 def
, b ?

What if the above ended with , b . instead. Well we'll come to that soon I hope.

Piping function outputs.

  3 add3 
|> add3
|> 2 add

will eval to

7 2 add

Conditionals

x if (x > 0) ?

Can we do else case like this?

x if (x > 0) or else -x ?

x if (x > 0 ?) else 0 if (x = 0 ?) else -x if (x < 0 ?) or else 1000000 ?

Quote

(+ 2 3)'

O.0: (+ 2 3)

Maybe we can use '.' to send it "into" the system, along the z-axis to evaluate it.

And use - to connect with other fellow functions in the same "plane" of abstraction.

But those are wild ideas, I don't want to get into now.

Can we use @ to denote apply?

apply @
eval |
quote '
bind &

x = (1 2 3)' def

Get h, t, r, e, s, p

(x 1 2 3)'t

Time

We havent defined any explicit timeline manipulating symbols/procedures but def can be seen as saying to the system "From now on, let it be known to this system that the following is a fact.."

and ? in a > b ? can be seen as "Tell me, as of now, is a > b etc etc".

We will try to build up the syntax and semantics of playing with time in later chapters. For now, let's use the following symbol scheme to denote a point in time or a tick (specifically a lamport's time stamp but we will come to that later).

We will represent what NASA calls T0 as .0 or . to denote now. And T+1 as .1 T-1 as .-1 or ~1

.-1
-- is same as
~1
-- not the same as

.1 - 1 ? --: .0

-- now is
.0

-- same as
.

chicken; worse then python, but 5 letters better than c!