DreamBerd; Perfect Programming Language

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Our great sponsors
  • SurveyJS - A Non-Cloud Alternative to Google Forms that has it all.
  • Appwrite - The open-source backend cloud platform
  • Amplication - open-source Node.js backend code generator
  • InfluxDB - Collect and Analyze Billions of Data Points in Real Time
  • Sonar - Write Clean JavaScript Code. Always.
  • Mergify - Updating dependencies is time-consuming.
  • DreamBerd

    perfect programming language

    Make sure to look at the example programs if you missed the link in the doc


  • ILanguage

    An interpreter for a J-inspired language

    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:


  • SurveyJS

    A Non-Cloud Alternative to Google Forms that has it all.. SurveyJS JavaScript libraries allow you to easily set up a robust form management system fully integrated into your IT infrastructure where users can create and edit multiple dynamic JSON-based forms in a no-code form builder. Learn more now.

  • signals

    Manage state with style in every framework

    Signals are a design paradigm for reactive programming which have recently trended in the JS frontend space. For e.g., https://preactjs.com/blog/introducing-signals/

  • TypeScript

    TypeScript is a superset of JavaScript that compiles to clean JavaScript output.

    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`.

    - 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`

    - 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

    - 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).

  • Web3CryptoWallet

    Web3 Crypto Wallet .acpul

    Naming - unicode by default and fully translatable

    Floating indexes in arrays. - works, but it called a map

    index 0.5;

    map.set.value(index, 123);

    When - works but with restrictions

    when if;







    Loops - there are loops here but no "break" keyword, just set the end value. Same for functions and there is no "return" keyword, use if(..)

    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

  • Appwrite

    Appwrite - The open-source backend cloud platform. The open-source backend cloud platform for developing Web, Mobile, and Flutter applications. You can set up your backend faster with real-time APIs for authentication, databases, file storage, cloud functions, and much more!

NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts