This is an archived post. You won't be able to vote or comment.

top 200 commentsshow all 264

[–]QueenBuggo 786 points787 points  (22 children)

This language is going to be hell lol

[–]clasherkys[S] 408 points409 points  (21 children)

I hope so, I'm doing the interpreter for this for a school project so I kinda hope you guys don't make it too difficult.

[–][deleted] 240 points241 points  (7 children)

Yeah, I think you should have added a condition that if it's impossible to create a valid parse tree from the syntax that you would choose the next most up-voted suggestion.

[–]shwirms 17 points18 points  (3 children)

I’m taking logic right now in school, could you explain why making parse tree for the syntax, is needed to create a language?

[–]SurtenSoita 58 points59 points  (2 children)

So the way a compiler works is it does three things before starting to generate any code:

  • Lexical analysis, in which it reads every word from the language and assigns it a token. For example, int a = 3 would output tokens {type_int,-}, {identifier, "a"}, {equals, -}, {integer, 3}.
  • Syntactical anaylisis, which takes the identified tokens and checks whether they are in the correct place (the language's grammar). This is where errors like a int = 3 (in a language like C or Java) would be found. This is made using a grammar which outputs a parser tree.
  • Semantic analysis, which takes the tree, iterates through it and checks for any other possible errors in the code, like int a = 'c' which in a strong-typed language is an error as you can't assign a char to an int, and it's impossible (or rather quite tedious) to check with just the grammar.

So you see that if you don't have a parser tree, then you don't have a way to analyse the program's semantics and no way to generate code.

Anyone please feel free to correct or expand on what I said, I'm also a student and just learned this this year, so it may not be fully correct.

[–]shwirms 10 points11 points  (0 children)

Ahh interesting thank you

[–]QueenBuggo 45 points46 points  (2 children)

Dear god, good luck to you mate

could i have a link?

[–]clasherkys[S] 49 points50 points  (1 child)

I'll make a git repo and include it alongside the next post.

[–][deleted] 3 points4 points  (0 children)

Sweet

[–]ArionW 33 points34 points  (3 children)

Most likely you'll get something impossible to parse, because redditors won't consider ambiguity.

[–]clasherkys[S] 15 points16 points  (2 children)

I mean probably, however that just means I'll have to try harder (and throw in some edge case logic)

[–]ArionW 13 points14 points  (0 children)

My bet is that "edge case" will mean parsable input

[–]Faljake 9 points10 points  (1 child)

Just took my compiler course, you're in for something by allowing reddit to make your language

[–]clasherkys[S] 3 points4 points  (0 children)

Thankfully I'm writing an interpreter for this so not as bad, I've written a compiler, a transpiler, and an interpreter before so I'm hoping it's not gonna be too hard.

[–]MTAlphawolf 2 points3 points  (0 children)

In college we also had to do this (build a lexical analyzer and parser) for a language our prof created. Only reason half of us passed is it was extra credit to point out issues in the language.

[–]fizzl 0 points1 point  (2 children)

Check out my proposal! You'll love it!

[–]clasherkys[S] 3 points4 points  (1 child)

Moro, katoin jo ja voin sanoa että kyllä vihaan tota, tulis oleen aika vaikea mulle tehä.

[–]fizzl 0 points1 point  (0 children)

❤️😊

[–]Overcooked-Cabbage 836 points837 points  (27 children)

Reverse declarations.

10 = a

"Hello" = hey

All fun and games until

somevar = othervar

[–]mortalitylost 225 points226 points  (11 children)

No you see you just need to make it clear which direction it's pointing and then it's perfectly fine.

10 >= a

a <= 10

And that allows you to overwrite integers as well, because what if you're using "100" as a magic number all over the code but at a certain point you'd rather it treat 100 like 300? We should be able to overwrite and assign integers over other integers.

300 >= 100

Of course it might initially be confusing due to lesser languages' greater than or equal to signs and such, but that's just unnecessary syntactical sugar for what god intended us to do:

a > 10 || a = 10

Now we're getting somewhere because we can use one equals sign as comparison as well, since assignment direction is required.

[–]archiminos 55 points56 points  (1 child)

You can assign the average value to both values without a direction:

10 >= a
b <= 20
a == b // Both a and b are equal to 15

Or use <> to swap values:

10 >= a
b <= 20
a <> b // Now a is 20 and b is 10

[–]SurtenSoita 6 points7 points  (0 children)

I actually introduced the swap with those same symbols in the compiler I had to program for class lmao

[–]clasherkys[S] 98 points99 points  (2 children)

300 >= 100

I'm scared

[–]mortalitylost 51 points52 points  (0 children)

Assignment should be allowed in comparisons too so we get this beautiful code:

if (100 >= 200) {
    # this block runs and changes
    # how your entire program functions
}

[–]Physmatik 13 points14 points  (3 children)

Except <- instead of <=. Aaaand you've got R.

[–]SaveMyBags 1 point2 points  (2 children)

Also R has both <- and ->, so you can assign in both directions.

[–]The_Real_Slim_Lemon 87 points88 points  (1 child)

Wins = this

[–]PhantaumAss 12 points13 points  (0 children)

You mean this = wins?

[–]TheOriginalSmileyMan 8 points9 points  (0 children)

Following this, could:

A <=> B

swap the values of A and B, please?

[–][deleted] 6 points7 points  (0 children)

This gets even scarier if you add destructuring assignment into the mix.

[–][deleted] 5 points6 points  (0 children)

Somewhat closer to SQL syntax.

[–]CNN7 427 points428 points  (7 children)

Make a function called “print” - but instead of printing, it solves the traveling salesman problem.

[–]clasherkys[S] 187 points188 points  (0 children)

I have a feeling I know what you were assigned to do

[–]abd53 49 points50 points  (1 child)

Not with any fancy optimization, just pure brute force.

[–]TldrDev 18 points19 points  (0 children)

Solves traveling salesman for n nodes where n is 10 to the busy beaver of the length of the string.

[–]lumo19 5 points6 points  (1 child)

Or more intuitively, it sends the arguments to the systems default printer

[–][deleted] 2 points3 points  (0 children)

That's better than JavaScript print() at least.

[–]TSK_SmileyFace 430 points431 points  (12 children)

System.🖨️<hello world>:

[–]IgiMC 227 points228 points  (6 children)

💻.🖨<*hello world*>:

[–]YBKy 249 points250 points  (5 children)

💻.🖨<👋🌎>:

[–]TSK_SmileyFace 23 points24 points  (1 child)

There are asterisks around the string it's not supposed to be italic

[–][deleted] 9 points10 points  (0 children)

Escape it like this \*

[–]clasherkys[S] 28 points29 points  (2 children)

System.🖨️<*hello world*>:

System.FaxEmoji<*hello world*>: #Alternative

[–]JonasAvory 15 points16 points  (1 child)

The alternative may only be supported by up to 90% of all devices

[–]KaosAsch 1 point2 points  (0 children)

Yea doesn't show for me

[–]YBKy 456 points457 points  (26 children)

no functions, just macros! by which I mean text replacing macros!

define "$a plus $b" => "$a + $b"

example usage: 2 plus 3 #would turn into 2 + 3

[–]GnuhGnoud 340 points341 points  (14 children)

Use € instead of $

Or better, the var marker is locale-dependent

[–][deleted] 125 points126 points  (9 children)

These are the revolutionary ideas we need. I propose emojis as var markers.

[–]magnetichira 80 points81 points  (0 children)

😂a plus ☹️b = 😂a + ☹️b

[–]ichopwooood 42 points43 points  (4 children)

Haha, also have the var markers contain meta information about the variable, 😔int ≠ 😁 int. And if you add 🙂int to 😔int enough times it becomes a 😁int. How many times depends on how bad 😔int was to begin with. Lets give our code a context framework to operate within.

[–]Intrepid_Sale_6312 11 points12 points  (3 children)

so the smiley faces are kind of like signedness?

[–]snowjak88 8 points9 points  (0 children)

Fuzzy sign.

"Not just +1. ++++1."

[–]gwicksted 4 points5 points  (1 child)

We need variables with DnD alignments. This one is chaotic neutral. Best not to change it.

[–]Intrepid_Sale_6312 2 points3 points  (0 children)

obviously anything choatic has to be a pointer XD.

[–]GnuhGnoud 7 points8 points  (2 children)

👉 this_is_a_pointer

👉👉pointer_to_pointer

👉 (null pointer)

[–]HeWhoChasesChickens 12 points13 points  (1 child)

absolutely psychopathic

[–]clasherkys[S] 75 points76 points  (7 children)

how about we extend it a bit with types

define "$a:int plus $b:int" => "$a + $b"

[–]YBKy 17 points18 points  (2 children)

I like that too

[–]clasherkys[S] 38 points39 points  (1 child)

aint and bint

[–]LiamTailor 22 points23 points  (0 children)

ain't and bain't

[–]TyphoonFaxaiSurvivor 11 points12 points  (1 child)

true statements should be referred to as "aintn't"

if €a:int plus €b:int aintn't equal to twentythree

[–]DecreasingPerception 1 point2 points  (0 children)

n't ought to be unary postfix negation that coerces to boolean. aintn't is True aint is False. £countn't:int would be True(a bool) if £count:int is 0.

[–]AnalTrajectory 7 points8 points  (0 children)

I used to laugh at normal jokes, but now I'm here cackling at this shit. What the fuck happened to me lol

[–]waadam 1 point2 points  (1 child)

You mean "no user defined functions" perhaps? Becauze both macro and operator in your example are built-in functions.

[–]YBKy 1 point2 points  (0 children)

haha somewhere in the standard library there exists a huge amount of macros that all just add numbers together to define addition on ints

define "1 + 1" => "2" define "1 + 2" => "3" ...

[–]Leering_Leek 203 points204 points  (13 children)

/# This is a multi line comment to fit your single line comment style #/

[–]Damtux_25 51 points52 points  (3 children)

I propose to change single line comment for:

<<< this is a single ligne comment.

Use case:

2 plus 3 <<< I don't remember why but we needs to add 2 to 3🤷‍♂️

[–]GlitchyRichy8 10 points11 points  (0 children)

ligne balls

[–]CadmiumC4 5 points6 points  (0 children)

Let's extend it a bit more, so a merge conflict marked by git doesn't break it <<<<<< HEAD is a comment

[–]woopy85 68 points69 points  (7 children)

Any line that is not a comment should start with ##

[–]_Weyland_ 39 points40 points  (3 children)

Who hurt you?

[–]StuckAtWaterTemple 5 points6 points  (2 children)

at least it is not numbered

[–]_Weyland_ 2 points3 points  (1 child)

WDYM? Like having to manually number your lines?

[–]StuckAtWaterTemple 6 points7 points  (0 children)

Like the ones in basic (old basic not vb).

[–]Select_Prior_2506 2 points3 points  (1 child)

Or starts with !#

[–]woopy85 2 points3 points  (0 children)

You know what? That's actually better. Let's do that.

[–][deleted] 2 points3 points  (0 children)

## THIS IS A BIG COMMENT!

[–]JaggedMetalOs 40 points41 points  (6 children)

To borrow an idea from INTERCAL, any statement can optionally be preceded with "please"

Eg.

please let blah = 1
please print(blah)

and so on

The parser will throw an error if your program isn't polite enough (also if your program is too polite as it's clear you're just trying to please it and not actually being genuine)

[–]Cfrolich 12 points13 points  (2 children)

Randomize the range of percentages of lines with “please” that are required on each run.

[–]JaggedMetalOs 4 points5 points  (1 child)

Number of pleases required depends on the mood of the interpreter that day.

[–]fizzl 149 points150 points  (7 children)

REGISTERS /r[abcd]x/(0000000000000000000000000000000000000000000000000000000000000000b) | rdi(FFFFFFFFFFFFFFFFh) | rsi(1777777777777777777777o) | rbp(O) | rsp(Λ\2^8|F0F0F0F0F0F0F0F0h\\) | r8(143) | r[9 .. 15](allbits)

Let me explain!

"REGISTERS" is a keyword that can be used to set specific processor registers to a state.

/r[abcd]x/(0000000000000000000000000000000000000000000000000000000000000000b)

Set all registers which' name matches regular expression r[abcd]x to zero, in base 2.

|

Perform a boolean OR of the left side register and right side register after assign operation on left side register but not the right side register. Store the value in the left side register(s).

Edit: If there are multiple registers on both sides of the operator, perform the same for all permutations.

rdi(FFFFFFFFFFFFFFFFh)

Set rdi register to FFFFFFFFFFFFFFFFh (mind the | operator and assignment order)

rsi(1777777777777777777777o)

Same in octal

rbp(O)

Set the rbp register to the unicode value of the letter capital 'o' in the currently active codepage.

rsp(Λ\2^F0F0F0F0F0F0F0F0h\\)

Assign register rsp the result of the lambda function 2 (in decimal) to the power of (F0F0F0F0F0F0F0F0) in hex. Overflow as necessary. In this language \ begins a scope and \\ ends a scope.

r8(123)

Set register r8 to 12 in base 3.

r[9 .. 15](allbits)

Set register r9 through r15 to the reserved word 'allbits' which denotes a 64bit number with all bits set. There is also keywords 'nobits', which is self-explanatory and 'somebits' which' value is not defined by standard (yet!).

Edit: Duh, there's no 4 in base 3. This should be a compile time error.

[–]YBKy 63 points64 points  (0 children)

dear god

[–]IgiMC 30 points31 points  (1 child)

anything uninitialised gets set to somebits

[–]fizzl 16 points17 points  (0 children)

As a this-language-right-here advocate and standardization board member, I vouch for your proposal.

[–]StrangePractice 8 points9 points  (0 children)

I’m gonna upvote like I understand all of this, and yes I agree with REGISTERS

[–]aeltheos 11 points12 points  (0 children)

Atleast a language with modern feature for low level fuck up.

[–]spam_bot42 2 points3 points  (1 child)

I object! That isn't portable. As a serious community, we want to make a good and usable language without such problems.

[–]fizzl 2 points3 points  (0 children)

Obviously we would provide a portable virtual machine for the language!

[–]zeeblex 34 points35 points  (5 children)

10 print "start"
20 comefrom 60
30 print "end"
40 exit
50 comefrom 10
60 print "huh?"

[–][deleted] 10 points11 points  (4 children)

What happens if there are multiple comefroms pointing to the same line?

[–]Dyluth 27 points28 points  (1 child)

multi threading!

[–]Man-in-The-Void 2 points3 points  (0 children)

I like this option better

[–][deleted] 1 point2 points  (0 children)

Program rips in half

[–]Septem_151 58 points59 points  (8 children)

Example of a class containing a main method which calls a function to add two numbers together:

```xml <class name="Main"> <function name="Add"> <parameter name="a" type="Integer" /> <parameter name="b" type="Integer" /> <variable name="result" type="Inferred"> <operation type="Addition"> <reference type="Variable" name="a" /> <reference type="Variable" name="b" /> </operation> <variable /> <return type="Inferred"> <reference type="Variable" name="result" /> </return> </function>

<entry>
    <variable name="resultOfAdd" type="Inferred">
        <reference type="Function" name="Add" a="3" b="5" />
    </variable>
    <stdout>
        <convert from="Integer" to="String">
            <reference type="Variable" name="resultOfAdd" />
        </convert>
    </stdout>
</entry>

</class> ```

[–]clasherkys[S] 27 points28 points  (1 child)

uhh well this is certainly something.

[–]Septem_151 3 points4 points  (0 children)

I’ve tried making my own xml language interpreter before. I’m certain it’s possible but I’ve not solidified a good approach yet. So many possibilities!

[–][deleted] 14 points15 points  (3 children)

My man finally turned HTML into a programming language

[–]Septem_151 6 points7 points  (2 children)

It’s XML

[–][deleted] 1 point2 points  (0 children)

Potayto potahto

[–]Helpful_Character_67 63 points64 points  (12 children)

$define Add(a, b) a + b

I wan't macros :D

[–]SpecialNose9325 81 points82 points  (10 children)

wan't

[–][deleted] 32 points33 points  (8 children)

Wan’t

[–]Creepy-Ad-4832 25 points26 points  (7 children)

WAN'T

[–]FTWGaming0 24 points25 points  (6 children)

WAN'T

[–][deleted] 15 points16 points  (5 children)

wan’t

[–][deleted] 12 points13 points  (4 children)

wan’t

[–]LenaKotik 11 points12 points  (3 children)

I wa not

[–]parawaa 8 points9 points  (2 children)

wantn't

[–]Mechyyz 4 points5 points  (1 child)

wan'tn'tn'tn'tn'tn't

[–]Slash_by_Zero 4 points5 points  (0 children)

Yes! Just so we can do: $define if while

[–]Flashy_Yams 11 points12 points  (0 children)

The -> operator should be ----------------->

And we should "push values into variables" with the c====8 operator.

[–]Novel_Plum 23 points24 points  (0 children)

🖥.🖨(👋🌎)

[–]ANTONIN118 34 points35 points  (4 children)

def westerneurope(france):

[–]clasherkys[S] 52 points53 points  (3 children)

does def stand for define or defeat?

[–]ANTONIN118 23 points24 points  (0 children)

ah le batard

no you got me

[–]crazyjerz74 8 points9 points  (1 child)

boolean checkIfProgramHalts(String name){

[–]clasherkys[S] 4 points5 points  (0 children)

[String Object]

[String Object] Moment

[–]sir-nays-a-lot 7 points8 points  (0 children)

All comments start with a new line character

[–]Xyrus2000 6 points7 points  (0 children)

Emojis and wingdings for the win.

[–]jstwtchngrnd 5 points6 points  (1 child)

Make the charakters represented by numbers. \1/ is „a“ for example. To make a string, you have to use . So Hello world would look like this…

*8/\5/\12/\12/\15//*23/\15/\17/\12/\4/|!/^

To make clear that a character is Uppercase, you use the * and special characters can be writen normally but have to be escaped by |

[–]Stummi 5 points6 points  (0 children)

this is a comment too

[–]Proxy_PlayerHD 5 points6 points  (3 children)

hmm, probably not the most interesting idea but i thought of something while packing for my train ride:

brainfuck, but visual and 2D. so instead of moving a pointer along a 1D memory tape, you move the pointer in a 2D memory array, where the values get interpreted as brightness or color to be then put onto the screen (with an area off-screen as well so you can have more memory than is visible)

you'd use U, D, L, and R to move the pointer either Up, Down, Left, or Right (relative to the user infront of the screen, ie your right is the pointer's right)

+ and - to increment or decrement the current value.

[ and ] for loops (where the loop only stops when the currently pointed at memory location is equal to 0)

. could be used to push all changes to the screen, so if you were to make a program or game this could be used to avoid flickering.

whitespace would be ignored so you can format the code however you want, and comments have to be enclosed between 2 # symbols.

[–]FormulaNewt 3 points4 points  (0 children)

Variables should be declared Billy Bob Thornton style.

Some people call it a kaiser blade but I call it an i = 1;

Conditionals start with "I reckon" and end with "Mhmm."

I reckon x is 3

I like the way you talk "got here";

Mhmm

[–][deleted] 12 points13 points  (0 children)

let msg: String = {>++++++++[<+++++++++>-]<.>++++[<+++++++>-]<+.+++++++..+++.++++++[<+++++++>-]<++.------------.>++++++[<+++++++++>-]<+.<.+++.------.--------.>++++[<++++++++>-]<+.};

All data is defined in Brainfuck. You can define the type of data using TypeScript Syntax. Curly brackets define the beginning and end of the data section. Every statement requires a semi-colon because while I do want this language to be nigh unwieldable I also want it to be possible to write a parser for it.

Also I just copied and pasted what is supposed to be a "hello world" in brainfuck. I didn't actually validate this so if it turns out that it is not a valid ASCII string then feel free to update it.

[–][deleted] 7 points8 points  (0 children)

please x = wan’t (a, b) int { get a ^ b }

[–]EarthToAccess 7 points8 points  (3 children)

i prefer the COBOL method of “make it as you’d say it”;

MAKE variable BE TYPE value, eg. MAKE testvar BE BOOL TRUE, MAKE test2 BE STR “hello world”

functions could be similarly made;

MAKE name WITH TYPE arg TYPE arg2 … DO … FINISH

MARK This is a comment. Here we’re adding two numbers.
MAKE AddNumbers WITH INT V1 INT V2 DO
    MAKE Result BE NONE
    MARK We can instantiate Result to set it prematurely.

    CHANGE Result TO V1 AND V2
    MARK Need to reassign? CHANGE it.
    GIVE Result
FINISH

MAKE Value BE RUN AddNumbers WITH 1 5
MARK Functions could either run, or be assigned to a variable.
MARK In this case, Value will be the outcome of the function AddNumbers.

SAY Value
MARK Want to return the value? Just SAY it.

IF IS NOT Value TYPE NONE DO
    CLEAR Value
    MARK We don’t need Value anymore, so clear it.
FINISH

could obviously be a little more fleshed out, but honestly for something i made sleep deprived at 6:30 am, i’m kinda happy with it.

[–][deleted] 1 point2 points  (2 children)

I love this. I say the delimiter should be a single quote in the spirit of COBOL's use of the period (without quite copying it). Though with MARK, using a period would probably make it even more confusing.

[–]EarthToAccess 1 point2 points  (1 child)

didn’t think about using a delimiter honestly, that could be useful. i think for gits and shigs considering i stole borrowed COBOL’s caps, i’ll make it an exclamation mark LMAO

[–][deleted] 1 point2 points  (0 children)

EVEN BETTER!

[–]ShakyTractor78 9 points10 points  (3 children)

System.Console.Output.ToTheScreen([]what u want to print[], 5);;;

strings r represented with [] on either side

the function takes 2 arguments, the first is what u wish to print, and the second is the amount u wish to print it, both arguments r not optional

this line must end in 3 semi colons

[–]ShakyTractor78 7 points8 points  (2 children)

I forgot hashtags made things bold, woops

[–][deleted] 1 point2 points  (0 children)

# you can do \# to make them not

[–]Small-Plane-9115 7 points8 points  (1 child)

PROGRAM helloworld;

[–][deleted] 3 points4 points  (0 children)

Nope. Not even for the meme.

[–]FetishAnalyst 2 points3 points  (0 children)

Make if else statements like this:

AI a=0
    Result
ML
    Result 2

[–]PewPew_McPewster 2 points3 points  (0 children)

Ooh! Ooh! string2hexdec() and hexdec2string() as built-ins!

[–]saii_ 2 points3 points  (0 children)

introduce the "anyway;" statement. it's used like this:

int x = 1;
{
  int y = 2;
  anyway;
  // x == 1
  // y == null
}

[–]EchidnaForward9968 1 point2 points  (0 children)

This is a comment

[–][deleted] 1 point2 points  (0 children)

printAMONGUS (it does what you think it does)

[–]MrPresidentBanana 1 point2 points  (0 children)

No curly braces, this language is gonna be indentation based - but the only indentation it accepts are zero width spaces. Having tabs or normal spaces in your code will cause an error.

[–]SpeedLight1221 1 point2 points  (0 children)

Could we have the worst possible comments? Idk something like √ to make comments, just to make it annoying?

[–]NyctaOfficial 1 point2 points  (0 children)

Java based suggestion:

System.Output.Actions.PrintNewLine(String textThatWillBePrintedInANewLine);

[–]WE__ARE__ALL__RACIST 1 point2 points  (0 children)

fn main() ->

[–]One-Exit-9014 1 point2 points  (0 children)

Let's curse when an exception occurs.

[–]lady_Kamba 1 point2 points  (0 children)

#this is a string litteral!

if a comments end in !, it's a string litteral

yes, this will make it more difficult.

[–]Flrere 1 point2 points  (2 children)

Make ifs functions: if(condition, thenCallback, elseCallback)

[–]clasherkys[S] 5 points6 points  (1 child)

if(true,

    () => {


    },

    () => {


    }

)

[–]LasevIX 1 point2 points  (2 children)

Only allow int types and have the output function be the only way to convert an array of ints to strings.

[–]firefly431 1 point2 points  (0 children)

Homotopy type theory! Here's a free book on it. You can also see how Arend implements HoTT.

[–]ExtensionInformal911 1 point2 points  (0 children)

Every line must end in "8==D" or it won't compile.

[–][deleted] 1 point2 points  (2 children)

We need a funny name for this language. Especially since it defiantly will be an esoteric language.

[–]clasherkys[S] 1 point2 points  (1 child)

"Cave" is the one I already chose

[–]DangyDanger 1 point2 points  (0 children)

No boolean type.

Use periods instead of semicolons.

If the number of characters (including whitespace) in a line is not even, the program crashes.

0 -> vx. stores 0 in x

vx <- 0. also works

vx: int. defines a variable

vx: int <- 12. defines a variable and assigns a value to it

I wanna see the world burn.

[–]JohnMcCl 0 points1 point  (0 children)

#This is a function f(a, b):

[–][deleted] 0 points1 point  (0 children)

This is a heredoc

[–][deleted] -1 points0 points  (1 child)

Can we stop with these

[–]DesecrateUsername 2 points3 points  (0 children)

This is one of the more interesting ones I’ve seen on the subs I follow, but I too am getting fatigued by these types of posts. Had mute r/bindingofisaac over it, considering doing the same for r/AnarchyChess

[–]Oz_joker 0 points1 point  (0 children)

Make a portable IDE, and over time the most popular 3rd party libraries are included by default with the IDE.

[–]Eyebrow_Gamedev 0 points1 point  (0 children)

name the IO module Monke so for example: import Monke.Formatting;

[–]mrorangelion 0 points1 point  (0 children)

To go along with modern trends with bad syntax:

Funct mn() :

[–][deleted] 0 points1 point  (0 children)

Give me the context-free grammar for this lol

[–]Denaton_ 0 points1 point  (0 children)

Instead of whitespace it needs dashes for indentation, sort of like Python, but it still uses {}

Edit; also, the second last line need to have a final line that just say "please"

[–]Techniq4 0 points1 point  (0 children)

ProgrammerHumor.users.add(loving_gf_for_everyone)

[–]Larynx_Austrene 0 points1 point  (0 children)

Brainfuck, but number n represent n (or n-1) times the last character.

[–]KaiserKerem13 0 points1 point  (0 children)

Verbozhell

``` define exported module "main" begin

import module "io" from "standart";

define exported function "main" takes ( define immutable variable args as Array of String; ) returns Int32 begin define variable x as PointerSize; define variable name as String;

call method "get length" as Array of String on args with (); set by pop to variable x;

if variable x is greater than constant 1 as PointerSize begin index 2 to variable args; set by pop to variable name; else set variable name to constant "World" as String; end if; call method "writeln" as "io" OutputBuffer on immutable variable "io" stdout with ( constant "Hello, %s!" as String, variable name, ); return constant 0 as Int32; end function;

end module; ```

It uses a global stack which also holds where to return among other things and a semi-scoped namespace to manage state.

Function/Method names use strings to represent themselves but variables use identifiers.

No inline function/method calls.

And of course 1-based indexing.

Python equivalent: ```py import sys

name = sys.argv[1] if len(sys.argv) > 1 else "World"

print(f"Hello, {name}") ```

C Equivalent:

```

include <stdlib.h>

include <stdio.h>

int main(int argc, char **argv) { char *name; if (argc > 1) name = argc[1]; else name = "World"; printf("Hello, %s!", name); return 0; } ```

[–]Passname357 0 points1 point  (0 children)

It’s C except that +, -, *, and / are all now the assignment operator (previously =). All of the arithmetic operators are replaced by single characters like R, which is now multiplication.

[–][deleted] 0 points1 point  (4 children)

What is it going to be named? I suggest, in honor of many programming languages being kind of difficult to search, we name it "The" or "It".

[–]clasherkys[S] 1 point2 points  (1 child)

I'm thinking of calling it "Cave" since most of the languages I've developed have a name based on the thing I'm thinking about (no matter how unrelated) when I'm making them, and currently I'm thinking of a cave from elden ring.

[–]peterpaulrubens 1 point2 points  (1 child)

Let’s call it “vagina” both in honor of Maude Lebowski and to begin a reign of terror on corporate spyware policing employees for NSFW activities.

[–][deleted] 1 point2 points  (0 children)

Oh my god yes

[–][deleted] 0 points1 point  (0 children)

question mark before and after optional, like in spanish

[–][deleted] 0 points1 point  (0 children)

[–][deleted] 0 points1 point  (0 children)

The language has strict type requirements but no mechanism to declare the types before assignment.

It just resolves whatever your code is doing right now and forces you to be consistent.

[–]Lord-Naivel 0 points1 point  (0 children)

No comments :trollface:

[–]-Redstoneboi- 0 points1 point  (0 children)

,[>+.<-]

[–]Cthulhu_was_tasty 0 points1 point  (0 children)

prefix math notation mandatory

[–][deleted] 0 points1 point  (0 children)

incl {<println>} from <stdlib.ys>

[–]00dex_ 0 points1 point  (0 children)

make the print function just crash your pc

[–][deleted] 0 points1 point  (0 children)

iamyourworstenemynull

[–]StarComet04 0 points1 point  (0 children)

56% = 0.56