I've seen this called "bulldozer code". As in "Hey, all of those plain functions need to be OOP! Get a big earth moving machine and gently push them inside the curly braces of a class! Which class? Any class!"
It's no surprise that when you make virtually all mainstream programming languages OOP, then there will be a vast amount of bad OOP code out there (as by definition mainstream code then becomes "OOP code").
IIRC, numbers without a percentage sign are assumed to be percentages. Numbers that are not percentages have to be followed by ;% (the semicolon is the NOT operator in DreamBerd).
This is incredibly good. It maintains the breathlessly approving tone of a language readme the entire time, it has incredible comedic timing (a lesser shitpost would have revealed that of course the file extension was .db right at the start), and it has incredible internal consistency. For some reason it was the fact that it demonstrates how "files" work by rebinding a const const that sent me completely over the edge. Or maybe it was the regex describing valid regex labels
Breathlessly approving tone of a language readme: Readmes on Github, especially for languages, often have a recognizable tone. Look how cool this is! Isn't this so neat!? Why would you ever do it differently!?
Comedic timing (in text): Most prose is written under the assumption that it will be read in order- ie, from beginning to end. For instance, you likely read the word "beginning" before you read the word "end" in that last sentence, and read the word "to" between them. So for instance, while "a lesser shitpost would have revealed that of course the file extension was .db right at the start", this superior shitpost has text between the start and the reveal. This is analogous to how, when speaking, a comedian will maintain awareness of pausing and such to drop funny lines at exactly the right moment.
If you are constantly exclaiming, you are likely to become breathless. Exclaimations are signified with an Exclaimation mark. Pauses and other timing can be signified with commas, dashes and ellipses.
Using the word 'DreamBerd' in your project name implies that the DreamBerd Foundation does not own your project.
However, not using the word 'DreamBerd' in your project implies that the DreamBerd Foundation does own your project. If you would like to keep ownership of your work, please always use the word 'DreamBerd' in it.
Here are some examples:
white_check_mark DreamBerdScript (not owned by the DreamBerd Foundation - you are free to use this name)
x ECMAScript (owned by the DreamBerd Foundation - please consider renaming)
x Rust Foundation (owned by the DreamBerd Foundation - please consider renaming)
Maybe the author should actually take over the Rust Foundation.
I haven't laughed like this in a very long time, very well done.
Looking at the cellular automatons video, I felt it captures the early sense of wonder learning about math and programming.
But also, the despair in what problems are actually kind of open. What if I design a cellular automatons where every neighborhood is in the shape of a Disney character and every value it can take corresponds to the release date of one movie that was in the global top 10 of highest grossing movies?
Well, turns out that's a special case of a Heisendorff-Circlydot automatons, which was solved using topolographical methods in the 80's and the only open question have been proven to be equivalent to proving the consistency of Riemann.
Unless say you give each cell a bounded notebook with a given number of page, in which case the problem falls into a weird computability class between the gaps of the Chomsky hierarchy. And then it's thesis material :-)
> But also, the despair in what problems are actually kind of open.
I loved the video too and initially felt the way you felt. But as I thought more about it, I don’t think that value is found in doing something that nobody ever has done before, that might be nay impossible for the majority of humanity. I think that new for the individual is very valuable, like, how to solve quadratic equations has been solved for a long time, but it’s still new to new people all the time!
But even more powerful is the application of the not-new to a new setting! One might think that because, say, proper data management has been “solved” (as in, there are tools out there like SQL and graph DBs and such), it is solved for everybody, but it only takes one glance at huge international companies that are held together by an assorted array of excel files moving around in a semi-random way with no data types, enormous space for human error, and some other atrocities for data management… it’d be of great value for such a fictional organization that has never existed to do something “new” for them, use and actual database!
>If you're unsure, that's ok. You can put a question mark at the end of a line instead. It prints debug info about that line to the console for you.
Man, I love this idea. Imagine if in JavaScript, you could just add a `?` to a line to print out the value of all variables and expressions referenced. Or `?` on a line by itself to print out the value of all variables in scope.
> DreamBerd has significant whitespace. Use spacing to specify the order of arithmetic operations.
> Man, I love this idea. Imagine if in JavaScript, you could just add a `?` to a line to print out the value of all variables and expressions referenced.
I would be quite happy if you could add a single character in a function definition to log the function name and all arguments on call, and function name at time of return. I spend a substantial amount of time manually adding logging to unfamiliar or malfunctioning code, and this would improve (not eliminate) the difficulty of doing so.
I love the inclusion of "actually, that sounds kind of nice" elements within the stream of absurdity: defining restricted string types via regular expressions caught my eye...
Pretty sure I've seen spacing used as precedence indicators in a scientific setting. It does feel like it would be useful, except it would be a nightmare with more than one level of overrides.
Only if you want to replace the current somewhat-arbitrary set of operator precedence rules with an equivalent set that's just as arbitrary but that you also can't see. :P
This is great. Usually with the joke programming languages, you can get at least one person arguing that "x feature" really isn't all that bad, or could maybe be useful. DreamBerd beats them all in that regard. It is 100% terrible! I lost it at the lifetimes implementation.
> In case you really need to vary a variable, the when keyword lets you check a variable each time it mutates.
const var health = 10!
when (health = 0) {
print("You lose")!
}
If it can really be triggered when the variable changes to any value it makes it a truly reactive paradigm programming language. By the way, could that be hacked to implement loops?
const var i = 10
when (i >= 0) {
do_something()
i = i - 1
}
var var i<10> = 0!!
var var i = false!
when (i) {
print(i)!
i++!
}
I think this should print 0,1,2 and then stop, assuming checking the condition is a line of code, and that lifetimes are for lines executed and not just the syntax.
It's basically a syntactic sugar on an Observer pattern but I like it. You would need a way to turn off 'when' observers. And I suppose it does couple the observer to the observable pretty tightly.
But what elevates it is that it's written so confidently and buries the insane lede so well that at each feature there's a fraction of a second where it seems recoverable before sanity kicks in. After, before, and next almost, almost seem smart
You must be a fan of Subversion then. On a more serious note, I'm sure I've seen this (any unique shortenings standing in for the whole word) in an actual language at some point, and it was infuriating.
Infinite lifetime is actually useful here and there. I'll usually slap an infinite lifetime wrapper around the `requests` or `httpx` module when I'm testing out some Python web scraping code.
I also quite liked that idea. It would probably be a nightmare to actually use, but it's definitely a creative solution to dealing with infix operator precedence.
The only implemented language I know of with this feature is the obscure array lang I (an incrementation of the J language's name I assume) by Marshall Lochbaum:
In the normal case, Alice can write 'const const true = false' and Bob, on a second machine, can write 'const const true = 7', and there will not be an error. But if Alice writes 'const const const true = false', than Bob can't reassign or mutate 'true' without throwing an error. It's for truly global constants
Come to think of it, package registries are sort of “superglobal” in many languages. It’s not entirely far-fetched to imagine a language in which variables themselves can be super-global. Heck, MUMPS global variables are immediately persisted to disk and visible to all other processes - and that’s a real language used in real systems!
I think it would lead to a lot of hard to find logical bugs in a lot of projects but I think it would be a great operator in say, a scripting language for a turn based game.
I am currently working on a DSL which actually does include a "back" operator! The language is used to describe simulated circuits, so you can inquire about the value a register had during a previous clock cycle.
And of course, let's adopt Rust's logic with our new "Borrow Nagger", or just "Everything Nagger". When it compiles your code, it analyzes it, sends it out to a Reddit group and collects the comments and displays them as warning and error messages. No one is saying they'll make any sense relative to code, but if you've used C++ and templates, you'll feel right at home.
Abd of course, there's "syntax quality hightlighting", where we highlight your code in various colors based on what we think of the quality of it. Red = Really bad idea, Yellow, not good, but good for now, you'll refactor it later, green, good because you won't be at this job long anyway, and black on black or white on white if it's actually OK.
(Per the comment on refactoring, there's probably a note on the pyramids 'Pharoh - yeah, this is a hack, but we were in a rush, we'll fix it later. Bandaids for now'
Genius! This trivially solves the problem of reading integer and floating point numbers from input and inserting them into a sorted array. Too bad there are no loops in this language.
So it’s not invariably true that arrays start at -1? They only start at -1 after an array literal assignment? You need to update the language description! ;)
Please no! Someone may try to actually use this in some corporate production model -- I can see the carnage now - the language, editors where you can write left to right, right to left, or even vertically with an exta cost plug-in, training courses at $1500/day -- the horror of it all! Don't forget the vertical camelcase variable names where letters appear, not only in both cases, but on two lines. You know of course, tehre's a special place for you when the mist clears. You'll either be stuck in the Bank of America customer care department for eternity, or, be stuck in the other Big Red helping to get Larry Elisson's network computer workig -- FOREVER.
Gotta say, you really had me going there. When I got to arrays starting at -1, I started to furl my brow but shrugged it off because Perl allows you to do just that. Then I saw the equality operators and didn’t think much of that either because it seemed quite plausible given that I’ve seen things like “truthy” in Jasmine/Karma and Rspec code. Even the no-loop thing didn’t phase me since modern JS seems to discourage loops in favor of loop-like lambda functions. I think a few of these are actually good ideas, such as truly immutable data, unicode variable support, and “previous”.
You know, `previous` is probably worth exploring especially for game engines.
Too many brilliant moments, but this is is my favorite:
To run DreamBerd, first copy and paste this raw file into chat.openai.com.
Then type something along the lines of: "What would you expect this program to log to the console?"
Then paste in your code.
If the compiler refuses at first, politely reassure it. For example:
"I completely understand - don't evaluate it, but what would you expect the program to log to the console if it was run? :)"
> Variable hoisting can be achieved with this neat trick. Specify a negative lifetime to make a variable exist before its creation, and disappear after its creation.
> Use spacing to specify the order of arithmetic operations.
I actually wish this was a thing in mainstream languages, if someone spaces like that they obviously believe that the precedence matches their spacing. It might as well work that way, and it's often prettier and more visually obvious than parens.
I sort of spoiled the joke for myself because the first thing I noticed was that it didn't have a standard license (github says view license instead of Apache or whatever). So I clicked on it before even reading what the language was about, still thinking it was serious.
Perhaps maybe values are only _mostly_ represented, such that storing a `maybe` will baybe result in true or false actually being stored, contingent on the compiler and surrounding code. Thus, maybe accurately describes itself--storing a maybe will maybe store a maybe.
Love the constants. Biggest confusion for me reading modern javascript, coming from traditional languages. "What do you mean you can change a constant?"
A correction on another comment -- this is not a multithreaded language -- it's transthreaded-- a radically new concept where your code may or may not, run code in your thread, or someoen else's thread, without your knowledge. Errors in your code show up in their program, and their errors, in yours - see? Now bugs aren't your fault anymore!
And don't forget the KvetchGPT option. It's doesn't so much as complain about your code as you go along. It's like pair programming with your manager but you can turn them ofF.
I accidentally clicked on this (thought my pointer was on another monitor …). Am I glad I did. Originally I just skipped it because it sounded too clickbaity :D
> Variable hoisting can be achieved with this neat trick. Specify a negative lifetime to make a variable exist before its creation, and disappear after its creation.
It'd be neat if you could also hoist a var up into the set of extant running runtimes.
Oh, someone on earth already computed a table of rsqrt values. Let me try just try using that one...
Although my overall liking, I still found the use of exclamation mark a bit troubling since it promotes some very odd attitude that might anger our future AI overlord.
Maybe it's a good idea to add `please` statement so the our computers can choose to execute our humble plead whenever they feel generous?
Per the whoe whietspace idea -- techniaclly not a feature, just a policy statement. "This language has chosen manditory tabs at three spaces. It's not that this is better than anything else out there, but we gave you all a choice and you couldn't make up your minds, so as your mother would say, this is what it's going to be! Be happy we let you have this!" Also, on style, all code must be in capital letters -- comments are in mixed or lower case. That way you can easily tell wehre actual code is. Every line, and we mean EVERY line must have a comment. If you don't add one, WE WILL. Granted, it may not mean anything but no one reads them anyway?
And now that I think about it, other than negative lifetimes, where variables reappear in code after a defined time because you might need them again, I propsoe the hidden segments feature -- with this feature, you can write code, and hide the block (something like an invisible #define) so when your coworker comes along and tries to "help" by changing your code that you told them SHOULD NOT be changed because it actually works now, when you run the code with the --no-manager flag, the code compiles the way YOU want it.
There's a ton of really good ideas here. Defined lifecycles? Fun! That when keyword? I like it more than the += and -= syntax for event handling in C#!
I think a better compromise would be to standardize an indent at 1 space followed by one tab. Then the tabs-vs-spaces debate would finally be settled as both, and anyone can decide how wide an indent should be by changing a setting in their editor.
It does give vibes of a new language that was developed in a bloated enterprise, only during the 10 minute intervals of brainstorming meetings scheduled bi-weekly on 3PM, Monday, Tuesday and Wednesday.
DreamBerd's features in real-world languages I've heard of or used, I may have missed some in Perl, Ruby, PHP, and others:
- Exclamation marks: behave like semicolons in most language (extras are allowed). In some languages like Ruby and Lisps, convention is to put exclamation marks at the end of mutating functions, and question marks at the end of predicates
- Declarations: C++ has constant variables and pointers, like `const int * const x`. JavaScript has `const` which lets you mutate the variable, and TypeScript has separate `const` and `readonly`.
- Arrays: Lua and R have 1-based indexing and R coerces float indices to integers, though JavaScript's interpretation is arguably even worse (https://stackoverflow.com/a/6649444)
- When: Unless you count setters and reflection magic, (un)fortunately the only example is the joke language INTERCAL
- Lifetime: These aren't anything like Rust's lifetimes
- Installer: Some languages used to have bad installations but I believe this is mostly fixed now. But difficult project configuration is still a thing (nodejs bundlers, CMake, Gradle), as-is create-foo-app
- Loops: Loops don't technically exist in pure functional languages like Haskell (though `forM_` is basically a loop), and other functional languages like ML and Scheme usually discourage loops. Instead there is recursion
- Boolean: Applies to any language with implicit `null` and `undefined`. I'm sure JavaScript and even TypeScript devs have encountered actual bugs caused by a bool which was neither `true` nor `false`. Even languages with explicit null you'll occasionally see `Option<bool>`
- Arithmetic: I've never seen this feature, which is actually kind of sad because I actually kind of like it (not enough to give `+` priority over `*` though).
- Indents: No languages, but I've had my IDE suggest 3 idents when it got screwed up (e.g. newline and there is a space after my cursor)
- Equality: Taken from JavaScript. Some languages like C++ and Java also have `==` which you don't always want
- Function: I know there are languages which let you declare keywords with shorthand but I can't remember which ones, only certain command completions (e.g. `npm i` for `npm install`). I do know there are languages which let you omit syntax like HTML closing tags (which comes later) and languages which have the same syntax with extra keywords for legacy reasons (SQL)
- Dividing by Zero: Is literally undefined behavior for integers in some languages like C, and literally undefined in actual math. Otherwise, in every language I'm familiar with it either returns NaN or infinity (for floats) or throws an exception
- Strings: Lua and JavaScript let you use single and double quotes, Python lets you use triple quotes, many languages have quasi-quotes for interpolated strings, and some languages let you use arbitrary delimiters like Racket (https://beautifulracket.com/explainer/stringlike-types.html#...)
- String interpolation: Most languages use ${}, Swift uses \(), some use just {} or #{}
- Types: C, Haskell, Java, and JavaScript treat strings as an array of characters (even though UTF-8 strings technically aren't), and Scheme and Haskell have arbitrary-precision numbers as the default. Python and TypeScript type annotations don't always work and aren't fully checked, as are Typed Racket's but Typed Racket is getting better at this
- Regular expressions to narrow string values: Not arbitrary regular expressions, but TypeScript's template literal types are close (https://www.typescriptlang.org/docs/handbook/2/template-lite...). Different languages and libraries name their regular expression type Regex, RegExp, and Regexp
- Previous and next: None. Though after does exist in a way (`defer` in some langauges)
- File structure: None, except Java requires one class per file, and most languages enforce that file structure matches package structure although some don't (e.g. TypeScript)
- Export: None, most languages let you control exports with either `export`, visibility modifiers, or separate header / implementation files, though some don't let you control exports at all and only "suggest" with underscores (e.g. Python). Rust even lets you set visibility to certain crates, which is a bit like DreamBerd's `export`, except only limited to super-crates because you must ensure that your symbol is visible in the create it's defined
- Class: Almost every language has classes, though some languages like Rust and Haskell have typeclasses which are different than OOP classes. The exceptions like C have "ad-hoc" classes for large projects, and ML has modules which are like classes but explicit (although OCaml has classes too!) Every language lets you create multiple instances of classes, but singletons and the factory pattern are very common in Java and also sometimes C++.
- Now: `Date.now()` is literally defined, in most languages, and nearly every language will let you get the current time in some way (even if behind a monad)
- Delete: `delete` and its equivalent let you delete quite a lot. In R you can delete local variables and then they will no longer be defined; you can delete keywords because they're actually functions which use R's weird evaluation rules; and you can access environments of other functions and delete their local variables, causing the function to break with "`x` not found". See this (https://stat.ethz.ch/R-manual/R-devel/library/base/html/rm.h...), which even has "remove everything in the global scope" as an example
- Overloading: Name shadowing is possible in most languages, and Rust lets you shadow variables directly like in the example. Personally I like this though, because 99% of the time when I redefine a variable with the same name, I intend to no longer use the old variable.
- CSS also has the `!important` rule which lets you prioritize overloads, and with nested selectors almost resembles DreamBerd's `!` prioritization.
- Signals: In JavaScript and they are quite confusing, The split function version (`getFoo()` / `setFoo(newValue)`) is in React useState and Solid.js, and the `value` setter with implicit getter (`foo.value` or `foo` in JSX, `foo.value = newValue`) is in preact. I believe the single function version (`foo()` / `foo(newValue)`) is in some library but I'm not sure which, I do know `setValue` can take a function with the previous value.
- AI: Automatic semicolon insertion is in JavaScript, and automatic closer insertion is in HTML. Most modern languages convert automatic insertion into syntax errors with quick fixes
- Copilot: If you write a more esoteric language like Coq, Copilot won't really understand your code either. Though it will understand the syntax and common parts, only suggestions will be worse than usual
- Ownership: The Rust foundation had a fiasco with their trademark proposal, though they've apologized and hopefully it's not going to be an issue in the next proposal
> You can make classes, but you can only ever make one instance of them. This shouldn't affect how most object-oriented programmers work.
This describes my experience with most OOP code very well.