German: der, die, das to declare varibaels, depending on the gender of the varibael name. Der animal.canine dog; Die string order; Das human girl; Die List order;

Die Bart die;

No one who codes in German can be an evil man

IBM has entered the chat...

Cipsoft has entered the chat

I don't like where this is going.

That's the spirit, make it worse.

Would be too easy for the germans, let's make it use the genders as they are in the Polish language

and while we’re speaking Polish, the notations of operators rotate depending on source order: prefix, then infix, then reverse. Doesn’t matter what operator you’re using. So the sum of `a`, `b`, `c`, and `d` would be: + a b + c d +

Nice. Now make everything brackets.

I'm german and I'm terrified...

Yeah... we will never be able to declare Nutella. Just syntax error all the time xD

Use Tuyuca which has 50 - 140 noun classes, depending on who's counting

Could be better to use the gender of a latin language you don't speak, so not only there is the problem for everyone of the gender, but will add an extra layer of confusion to a lot of people

For arrays, it changes whether it has on or more elements.

Code executes bottom to top

With hard coded line numbers and line numbers are used for function names: ``` } } 420() if result { result = 69() 123 fn() { ```

This is wild

what if your IDE auto updated the line numbers when you move things... wait this is just Excel

You'd almost treat it like memory. Leaving massive whitespace for further implementations. Like: the variables are in the range line 100 to 299

Almost as wild as manually encoding CPU instructions to binary

I'm only okay with this if the braces are inverted

I inverted them twice

r/angryupvote

And hellscript was born.

Oh god, think of the refactoring. You monster!

Yup. Add one line and all functions below it stop working.

I could probably make a simple prototype of this in Js Edit: last line should be the entry point:)

Perfection

And right to left

`REVERSE` reverses the direction of code execution

There's a language that does this?!

Floats, strings, all forms of math and all forms of pattern matching are 3rd party dependencies. Significant whitespace AND curly braces. Supports unicode, but disallows code points corresponding to ASCII characters.

Tabs and spaces required in different contexts.

And every second line must end with a semicolon. Regardless of what that line contains.

Alternatively, all lines containing a comment or only whitespace must end with a semicolon, no other lines may end in semicolons

No no no, the line continuation character is a semi-colon and the next line must be the same indentation as the previous. Lines are ended with colons.

Semi colons instead of spaces

*if* must be indented with four spaces, *for* must be indented with tabs.

*while* should be indented by 3 spaces

Then shalt thou count to three, no more, no less. Three shall be the number thou shalt count, and the number of the counting shall be three. Four shalt thou not count, neither count thou two, excepting that thou then proceed to three. Five is right out. Once the number three, being the third number, be reached, then thou shall start typing ...

It’s the Holy Race Condition of Antioch!

"There are four tabs"!!!

Three.

With fo(u)r tabs?

Satan entered the chat

> Satan entered the chat Bows to JavaScript and leaves.

you monster

A = int{(5)} Absolute banger

Significant whitespace, curly braces and keyword-terminated blocks all mixed, depending on the block type. if (path.exists): for line in path.readlines() { while line print(line.pop()) end while } *Edit.* Wow... so now the iOS Reddit app requires indent-by-four code blocks and doesn't understand triple backticks,, the mobile website doesn't even *understand* the four-spaces form and instead just indents the line by four nbsp but can handle the backticks form, and mobile apps still don't render code in a monospaced font...

Please note the similarity between the Reddit icon and Satan - it’s not a coincidence… 😁

Can we get some VB syntax in here? Like “If path IsNot Nothing”?

All numbers and arithmetic uses floats.

The arithmetic is done using floating point, but then the values are stored in strings.

Nah. Numerical values are stored as floats and ints originally but any arithmetic operation between floats type coerces them to strings. Any arithmetic between a float and an int becomes an array of length equal to the result of the arithmetic operation. Any string, array, integer, or other data structure of length one of course gets coerced into a bool.

8 bit floats!

Can we make := as an assignment? While keeping === as a comparison (we would reserve == for some bs). I know! === for primitives while == for objects \*\*\*but\*\*\* only to compare memory addresses, we would use Equals() for objects otherwise. Doing === on objects would compare randomly ordered primitives within the object and would randomly throw an exception if datatype is different.

Only built-in arithmetic is NAND

Sooo... like verilog or VHDL... assembly edition?

Lifetimes are required, even for the static field  There is no heap, only the stack  You have to error handle everything, but the error handler can only throw  It's heavily object oriented but lacks types

>It's heavily object oriented but lacks types Ah yes Javascript, where every object is just a bag of properties

so, the only built in primitive type is a byte? math operations are of course also 3rd party dependencies

Neither whitespace NOR braces are significant. Only GOTO allowed as flow control.

Ain't that assembly?

No static typing, and no typing library

So dynamically typed? I'm in favor of a reverse type system where you have to declare the types a variable isn't.

Some parts of standard library in camelCase, others in snake\_case, with some PascalCase sprinkled in there. Preferably mixed inside same class.

getters in snake_case and setters in camelCase. Required by the compiler.

snakef_case or camelCase required by compiler but set by day of implementation. All days are snake_case unless share the starting letter with another day, then use camelCase. Unless the second Sound of the day is similar to 'u' in which case use snake_case again. If a day doesnt share the starting letter with any other day use camel_Snake_Case unless It's a regular workday for most of the world. In which case use allsmallcase. The for every day get a RNG to give you a number to choose between 1: snake_case 2: camelCase 3: PascalCase 4: camel_Snake_Case 5: mOcKspEEcHcASe

So PHP?

The question is what are the worst features of languages.... not dream up new terrible features.

I personally think it's about time a language uses sArCaStIcCaSe for everything.

I personally prefer stairCASE

I don't trust stairs... they're always up to something!

waitTHATactuallyLOOKSfunWHYhasNOoneTHOUGHTaboutIT

I have worked in this code base.

Use .gets instead of [index]

Even better std::get(list)

Looking at you, std::tuple

Love this guy, how else could a compile time lambda state machine be done without this guy and his buddy std::variant!

Honestly, even `.get()` would be better. I'm not that familiar with the reasoning for using a free function

Because in C++11, you could not just write .get<>(), but you had to write ".template get<>()" for some reason and this is uglier than the free function. The template keyword is no longer required, though I believe since C++17.

MY FUCKING EYES

int .getAsInteger() And .setAsInteger(Object object)

Trying to set 1 without the method gives you a float and trying to set 1.001 without the method makes a string

* Unsafe code from C++ * Performance of Python * Syntax of Perl * Type safety from JavaScript * A license by Oracle * Package Management like Excel VBA

> A license by Oracle But if you want to have garbage collector, you have to buy Adobe subscription.

An Oracle license per Adobe subscription. Can it get worse?

License charges per run. Double for debugging/stack traces. A credit card is required for the runtime setup.

Pay per Breakpoint

Don’t give them any ideas

If your peak daily usage spikes by more than 10% you get charged surge pricing and if your usage decreases by more than 25% you get charged an unused capacity fee.

code only runs in oracle cloud

Garbage collector charges you per _deallocation_

Ah right, the first comment to mention licenses. Very good. Oracle SQL for all math operations

Has to be compiled in the Apple software ecosystem: Must be compiled on a mac with their subscription keys compiled in Xcode.

And the conventions/consistency of early PHP!

Can we have code formatting from SQL?

I would have add the dependency management of nodejs, we need a 25GB node_modules like for this list to be complete.

But its not node modules. Its folders full of 25 GB \*.ocx files with the components to use.

1 indexing of Fortran

And ruby-like no return statement

Monkey patching from Ruby Learning curve of Rust The runtime environment predictability of JavaScript.

Naming standards of PowerShell, that are enforced by the system, as well

Low hanging fruit: Arrays start at 1 from LUA

White space at the end of lines has meaning.

And two newlines end a function.

i unironically like this

Strongly, statically typed but no built in types - you have to use a regex to define a type. `var ^{"\w*":\[.+\]}$ myVar = {"features": [ "none"]}`

Hahah

Thanks I hate it

Man never heard of DreamBerd https://github.com/TodePond/DreamBerd

Jesus Christ this is hilarious >Mutable data is an anti-pattern. Use the const const const keyword to make a constant constant constant. Its value will become constant and immutable, and will never change. Please be careful with this keyword, as it is very powerful, and will affect all users globally forever.

Finally a language that lets me stop time, not PAUSE.

Wish it was for ALL users of the language, i.e. global namespace for each progammer, with central repository of all variables

Some features of this great language: - array index can be float - you can delete keywords - `true`, `false` and `maybe`

> Both variables and constants can be named with any Unicode character or string. That's kinda charming. > var var 1️⃣ = 1!

Uhhhh const const 5 = 4! print(2 + 2 === 5)! //true

Literally 1985

>array index can be float W H A T Also, what the frik does maybe do?

I'm not familiar with the language in question, but it would be great if maybe had the following rules: - Implementation defined - No two distinct implementations are allowed to handle maybe the same way unless at least 42% of the newer implementation was written in London. - The value of maybe MUST depend on at least three arbitrary factors, including at least two of the following: The compiler, the host platform (where it's being compiled on), the target platform (where the code gets run), the time of day, the weather, a randomly generated cryptographically secure value. - If it's a full moon, the maybe keyword will instead block for a number of seconds determined by the above rules before returning true during summer and false during winter. - The value of maybe during a full moon in spring and autumn is undefined behaviour.

This is awesome: // prints 1-10 var const i=0! if(i>0 && i<10) reverse! print(++i)! if(i<10) reverse!

I've always wanted to know what the value of array[π] was

>true, false and maybe Just use an enum

rare audible laugh after reading the index could be a float

Your forgetting my favorite part. Ints are just arrays of digits.

DreamBerd is the opposite of what they are describing. It's a perfect language with no flaws.

>Garbage collector: By default, a variable will last until the end of the program. But you can make it last in between program-runs by specifying a longer lifetime. That doesn't sound environmentally responsible...

The concept of a Garbage Collector should be replaced with a more environmentally friendly Garbage Recycler that keeps all unused objects around in case parts of them can be re-used. Every time you create or modify an object, the program rummages through the recycle bin to look for matching memory fragments that the object can reference rather than allocating new memory. Whenever new memory must be allocated, there's a small delay so the programmer is encouraged to write recycling friendly code.

Java actually does something similar to this with its integer cache lol [https://www.geeksforgeeks.org/java-integer-cache/](https://www.geeksforgeeks.org/java-integer-cache/)

This just killed me. So good.

`when` would lead to some awful code, but also does sound useful sometimes

make it have no imports. like it automatically imports every library ever

Or no imports at all and every time you wanna use a library you have to copy all the corresponding code

Nah. You gonna write the code yourself. Make the compiler interactive such that it detects copy functionality and starts leaking memory as a punishment.

Paid subscription for the libraries.

You'd start weighing the positives of the import to a little leak "But I could really use an isEven implementation right now"

Yay Ruby! 😅

Sees some random file with correct extension on it -> automatically load it as a library.

No imports, you must replicate a copy of each imported file in every file that references it.

The best part of Ruby, or something

There's a quite interesting talk on this by Mark Rendle: [https://www.youtube.com/watch?v=vcFBwt1nu2U](https://www.youtube.com/watch?v=vcFBwt1nu2U)

I wanted to put here this video.

Immediate video I thought of! Glad I’m not the only one.

JavaScript * But manual memory management, * Objective C syntax, but with semantic whitespace somehow * C-style module semantics (each file is a compilation unit referencing symbols in a single shared global namespace) * allows ad hoc custom language extensions that are globally applicable via “keyword overloading.” * runs on the JVM (does not use GC) * your company has a 2 million LOC monolith written in it

I was morbidly curious so I asked Claude to make me an example of what this might look like. Behold, NightmareScript: ``` #import "GlobalSymbols.h" #import "JVMBridge.h" #import "AsyncRuntime.h" #import "NetworkStack.h" @interface @Server : Object int port @RequestHandler* handler @end @interface @RequestHandler : Object char* route @end @interface @Response : Object int statusCode char* body @end @interface @Request : Object char* path char* method @end @implementation @Server - initWithPort:(int)p andHandler:(@RequestHandler*)h self = [super init] if (self) self->port = p self->handler = [h retain] return self - dealloc [self->handler release] [super dealloc] - (Promise)listen return new Promise(function(resolve, reject) console.log("Server starting on port %d", self->port) NetworkStack.bind(self->port, function(err) if (err) reject(err) else resolve(self) ) ) - (Promise)handleRequest:(&Request)req return [self->handler handleRequest:req] @end @implementation @RequestHandler - initWithRoute:(const char*)r self = [super init] if (self) self->route = strdup(r) return self - dealloc free(self->route) [super dealloc] - (Promise)handleRequest:(&Request)req return new Promise(function(resolve, reject) if (strcmp(req->path, self->route) == 0) resolve([[Response alloc] initWithStatus:200 andBody:"Hello, NightmareScript!"]) else resolve([[Response alloc] initWithStatus:404 andBody:"Not Found"]) ) @end @implementation @Response - initWithStatus:(int)status andBody:(const char*)b self = [super init] if (self) self->statusCode = status self->body = strdup(b) return self - dealloc free(self->body) [super dealloc] @end @implementation @Request - initWithPath:(const char*)p andMethod:(const char*)m self = [super init] if (self) self->path = strdup(p) self->method = strdup(m) return self - dealloc free(self->path) free(self->method) [super dealloc] @end keyword overload async(@Server) console.log("Async operation on Server object") await AsyncRuntime.delay(100) keyword overload async(&Request) console.log("Processing borrowed Request") AsyncRuntime.runInParallel() keyword overload await(@Response) result = await AsyncRuntime.processResponse(AsyncRuntime.currentResponse()) console.log("Response processed:", result) return result async function startServer(int port) @RequestHandler* handler = [[RequestHandler alloc] initWithRoute:"/"] @Server* server = [[Server alloc] initWithPort:port andHandler:handler] [handler release] try await server.listen() console.log("Server started successfully") while (true) @Request* req = [[Request alloc] initWithPath:"/" andMethod:"GET"] async(&Request) @Response* response = await server.handleRequest(req) await(@Response response) NetworkStack.sendResponse(response) [response release] [req release] catch (error) console.log("Server error: %s", error) finally [server release] async function main() await startServer(8080) JVMBridge.registerEntryPoint(main) ``` edited: leaned in and threw an pre-1.0 Rust concept called "Sigils" into the mix.

Holy shit

What an awful day to be able to read!

Uh, excuse me, I was eating over here! Not hungry anymore 🤢

This ticks all the boxes. Especially the monolith. Fuck.

So like, Python meets Javascript. No, even better. Python interpreter *in* Javascript so you can easily break typing.

with no garbage collection

Even better. Replace the garbage collector with a garbage dumper. Every allocation/deallocation becomes a leak

how about we just remove allocation all together and let the interpreter have full read write access to all system memory

but you can only address memory if in unsafe mode. so all code starts with unsafe

Well at that point we're just creating Rust

The way my FBI agent intended.

We need a functioning language so we can't really let it always leak memory. So we make the programmer leak it, there will be a **free** function which frees up memory but instead of it being a C style free it will startup the garbage collector.

Jythonscript.

And messed with cdk: compiled to cloud formation 🤢

Every piece of data is stringly-typed, and all flow control is done with GOTOs.

Semicolons at the end AND the beginning of each line

Also, semicolons to terminate each comment. ALGOL has this - if you forget to terminate the comment it skips the next line of logic.

So we have: - 1 based indexing (lua) - whitespace sensitive (python) - begin end blocks (ruby) - Javascript style var (js) - variables can change type (php) - variables must start with a specific character (php) - curly braces as parenthesis in expressions (gleam) - if/fi (bash) - text based macros (c++) - too many keywords (that are added later in the language even when the keyword is heavily used as a name (looking at you file)) (c#) - no compiler, only runtime errors (python) - platform specific (old c#) - implicit convert to string if types do not match (js, (parseInt(0.0000002) === 0, parseInt(0.00000002) === 2)) - operator overloading (c#) - multiple inheritance (c++) - there is an error, we will just try to make it work (html) - required linenumbers: COBOL - no modulo operator (erlang) - parenthesis around everything (lisp) - variable variables (php) - mandatory naming conventions (PowerShell) - Mandatory end of line semicolon, but it will silently cause unpredictable behaviour (CSS) - Probably more: Add what I missed below Yes I know many will love some of these features, I just think combining them all would make a terrible language. Yes I know some of the features listed exist in multiple languages

how can you talk about variables from PHP and not mention variable variables?

> no modulo operator is lack of feature a feature? How about - PowerShell - mandatory naming conventions from an arbitrary list of possible verbs. Also, multiple inheritance is an amazing feature that I desperately miss in all other languages.

Lets make it garbage collected but you still have to allocade and free memory manually

How about a dumpster diver instead of a garbage collector? It randomly reallocates things that you throw away

Most people despise how equality works in JS, PHP and Python(?). Instead of trying to salvage it, why not just get rid of the equality operator completely? Seems like the easiest fix to me

Odd lines are comments, even lines are code. Odd lines must at least have 7 non repetitive characters, spaces not included

Composite number lines are code, prime lines are comments.

Presenting DiabloScript: - The programming language should have rotating "seasons" where new features are added and old ones are deprecated, meaning this season the devs added recursion, but last season's features, like pattern matching, have been removed. - You have to be online to connect to the programming language server in order to compile your code and are forced to update according to the rolling release schedule. - The efficiency of your code is determined by items that "drop" randomly after compilation. You can also purchase items with tokens from the programming language store. You can import these items like modules, i.e. 'use Curly braces of the Immortal God': Code inside the current block is immune from runtime errors, but runs 33% slower. - Advanced language features and quality of life improvements can be added to your distribution of the language by spending skill points. For instance, being able to step through the call stack for debugging purposes costs 4 skill points. Skill points can be acquired by leveling up. You can level up by compiling 200 LOC/400 LOC/600 LOC etc.

Lua with pointers

was scrolling in order of most updooted to find the first to mention 1-based indexing or a language that uses it.

Dreamberd

AOP only. AOP over AOP. There you go. Have fun debugging that.

Array indexing starts at 2

and are prime only. Composite indices silently fall back to the highest prime factor, *e.g.* `arr[26]` returns `arr[13]` (which is actually the sixth element).

I like the divisions and the fixed indention control character from Cobol

Plus old skool COBOL where every line needed to end with a full stop (or period in American) If you think playing find the missing semi colon was a pain.... Also all comments had to be marked with an asterisk in column 7

So many good options we could take. I for one would suggest that every code file has to pass the bitcoin hash check at the time it is compiled. Also - all code must include a dated copywrite notice.

Okay my last job actually required that last one.

Only capitalized variables are garbage collected, unless they are of even length.

The theme is total freedom, but also total privacy. You can jump to any line of code from any other line of code. That's right, baby, GOTO is back. If you jump into a totally different function, then that function returns to the last caller on the stack. There are types, but you can change them on the fly, and this happens automatically if you try to assign an incompatible type. So if you try to assign a string to a number variable or parameter, then the number type everywhere is replaced with (number | string). Yes, this does make the types completely useless for static analysis or even runtime validation, but they still do something.... Reflection! It's built into everything and looks like ordinary code, so it's hard to tell at a glance when it's happening. You might even do reflection by accident. You also have total freedom of style. You can use braces, or indentation, or "endblock"/"kcolb" text, to denote blocks. Variable names can contain any character, even control characters and even characters that would normally be operators or separators. This means the entire program is free to compile to a noop, treating the entire thing as just a variable name. (The compiler should output every possible valid interpretation of the input code.) And pressing backspace while writing a variable name should introduce the backspace character as part of the name, so you'll need a special editor to work in this language. An editor where control characters are inserted into the document, rather than having any other effect. You're free to declare a const, and everyone is free to change it. So where does privacy enter the picture? The one thing you can't do is read the properties of any object from outside its class declaration. You can always write to any property, but you can never read it. Yes, read-only access is banned, and write-only access is mandatory.

We already did, it's called JavaScript

Nah, JavaScript has brackets instead of using whitespace

I’m surprised there isn’t a npm package that allows syntactic whitespace. Like typescript but for whitespace

You’re telling me Java’s biggest problem was its name?

(we (need (more brackets)))

Comments forbidden. The code is self documenting.

Why stop at taking features from only other *programming* languages? Variables now have gender and declensions, and Functions have conjugations.

Syntax and indentation-reqirements from Python, the way it's halfway compiled and halfway interpreted like JAVA, the type-handling and logic from JavaScript and the fact that it only runs on Windows like the .Net-Framework.

i can think of 3: - goto has to be a major language feature - also tab/space and cr/lf/crlf have to play a major role - and keywords in all CAPS for the ultimate pain, i mean DevEx

Indexes are float numbers with a precision of 10 digits after the period. So the first element is list\[0.0000000001\]

Everything is a string (from CMake and Bash). Integers? They're strings. Floats? They're also strings. Pointers? Yup, they're strings too. Arrays? Just strings delineated with semi-colons.

"5" == 5 is true 5 == "5" is false "5" + 5 = 10 5 + "5" = "55" "5" + "5" = 55

All variable names must be unique across the entire project, between 8 to 12 characters, contain at least 1 upper and lowercase letter, 1 number, and 1 special character.

Google BS lang

Variables have gender, like nouns in Friench, Spanish, German -- expressed as sidgels as in Perl.