DreamBerd is a perfect programming language
github.com
github.com
> 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.
As for OOP, a bit more realistic would have been to restrict interfaces to at most one implementation.
https://gwern.net/doc/cs/2005-09-30-smith-whyihateframeworks...
Note that one of the comments is from me :-)
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").
DreamBerd probably allows this.
If not, maybe you can hoist the ability to hoist % symbols, before which you can hoist % symbols.
I'm more inclined to follow the bell curve. 10% crap, 40% mediocre but rather bad, 40% mediocre but rather good and 10% great.
That sounds interesting. Who has researched/written about that?
What does this mean?
it has incredible comedic timing
How does text have comedic timing?
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.
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)
Please note: I will close any issues without unreproducible steps.
Surely you meant "without reproducible steps"?
The latter could be phrased like this: "Please note: I will close any issues with reproducible steps."
For more info, please read my blog post "Why unreproductions are required".
I think you should support the following API
Start(x,y)
LineTo(x,y)
Circle(x,y,A) // A is area
Triangle(ax,by,ay,cx,cy,ay,bx) //Most Intuitive coordinate order
RestOfEffingOwl()But you guessed right at least the features from my ACPUL no-keyword programming language.
Here is a quick comparison DreamBerd vs ACPUL:
! - should use ';' and use everywhere if(..){..}; This is important!
if (;true) - no boolean operators !, &&, || etc. no else. use
if (a==0){
true;
};
if (a!=0){
else;
};
Floating indexes in arrays. - works, but it's called a map
index 0.5;
map.set.value(index, 123);
when if;
when(a<=10){
a+=1;
};
if(r0){
a:=1;
};
Indents - 1 space ident is highest priority. Maybe your editor ident: 2 space or 4 space, -3 is possible, but rare case
Function - don't need to write any keyword like 'fn' or 'func'. just func1 {..};
Strings - all strings always zero quotes. var=STRING;
File Structure - Yes! Really usable and it looks much better than other languages
AI - fully designed for AI copilot and works with partially defective code
..and it works. I wrote a lot of code. Lets fun :)
Here is the demo app https://github.com/web3cryptowallet/Web3CryptoWallet
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 :-)
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!
They stole the feature directly from python!
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.
I might be mad, but this seems...almost...useful?
It’s like someone lost one bet and then won another, and, resultantly, humanity lost…
https://en.m.wikipedia.org/wiki/Fortress_(programming_langua...
Tomorrow is today: https://twitter.com/TodePond/status/1595464031728459776
In library form: https://todepond.gitbook.io/habitat/documentation/console
> To declare a function, you can use any letters from the word function (as long as they're in order):
> function add (a, b) => a + b!
> func multiply (a, b) => a * b!
> fun subtract (a, b) => a - b!
> fn divide (a, b) => a / b!
> functi power (a, b) => a * b!
count func (a,b) => ...
in out (a,b) => ...
of if (a,b) => ...
Here are some of my favorites:
union
funi
funion
fution (sounds like fussion)
fu
fuc
fucton (as noted by a fellow commenter)
I mean constant constants, constant variables, and variable variables seem useful.
I'm not sure how would variable constants be useful.
Also, anybody knows the difference between constant constant and immutable data (constant contact constant)?
> 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")!
}
const var i = 10
when (i >= 0) {
do_something()
i = i - 1
}Maybe Prolog is the perfect language.
functi fibonacci (n) => {
const var sum = 1!
const var i = 0!
when (i < n) {
sum += sum + previous sum!
i++!
}
}
when (i < 10) {
fibonacci(i)?
i++!
} var var i<10> = 0!!
var var i = false!
when (i) {
print(i)!
i++!
}
Side-effect is that it will delete all the whens, so only use it if you need it!
About coupling, an implementation could send state change events to a message bus and observers could subscribe only the events they care about.
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:
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.
const var scores = [3, 2, 5]!
scores[0.5] = 4
print(scores) //[3, 2, 4, 5]!
(Remember that arrays start from -1.)
scores[-2] = 4!
scores[-1.1] = 4!
If you did the first, then the second one, two 4s would be placed at the start.
const var scores = [3, 2, 5]!
scores[0.5] = 4
print(scores) //[3, 2, 4, 5]!
scores[-2] = 10
print(scores) //[10, 3, 2, 4, 5]
print(scores[-1]) // 10
const var i = 10
when (i >= 0) {
do_something()
i = i - 1
}To avoid confusion, the delete statement only works with primitive values like numbers, strings, and booleans.
delete 3!
print(2 + 1)! // Error: 3 has been deleted
HAHAHAHAHA
delete class!
class Player {} // Error: class was deleted
delete delete!var var meanings = [42]!
print(meanings[-1])! //42
[++! //temporarily change to 0-based indexing
print(meanings[0])! //42
print(meanings[-1--])! //42 (because of the --] pre-decrement)
https://perldoc.perl.org/5.20.0/arybase
It was even more fun in Perl 4, when $[ was program-scoped o_O
By the way, what is a Signal?
In particular this:
Technical info: Type annotations don't do anything, but they help some people to feel more comfortable.
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? :)"
const const const delete = delete delete!
Perhaps I'm odd, but that really made me laugh.
The kOS plugin for Kerbal Space Program implements a programming language that actually has this feature.
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.
> Technical info: Booleans are stored as one-and-a-half bits.
Technically, ternary values would be ~1.5849 bits.
Perfection.
But yes you can modify objects and arrays of a constant, which is not great.
https://github.com/TodePond/DreamBerd/blob/main/test/test/te...
(I expect the downvotes now)
> print("Hello world")?
That is great, though.
No you can’t store three choices in one-and-a-half bits. Two booleans would be 9 choices whereas 3 bits can store only 8 choices.
Flex
Or maybe start with 0.25, since starting with 0 is three times better than starting with 1.
Dividing by zero returns undefined
it took me a few minutes of thinking before finding why it's wrong
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...
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?
Something that makes (a) you appear smarter than other developers and (b) your code so complex it is unmaintainable.
In JS you could then replace
[x,setX] = useState(0);
with
x = 0;
the examples miss the perfectly cromulent 'unction'
That's what a former colleague, who shall remain unnamed, suggested as well.
> Please remember to use your regional currency when interpolating strings.
- 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`.
- Naming: Lisps let you put punctuation in names, and see https://codegolf.stackexchange.com/questions/28786/write-a-p...
- 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
- Compiling: Most languages can compile most programs. However C++'s parsing is literally undecidable (https://blog.reverberate.org/2013/08/parsing-c-is-literally-...), as is TypeScript's type system (https://github.com/microsoft/TypeScript/issues/14833).
scores[0.5] = 4
print(scores) //[3, 2, 4, 5]!