I think effects and effect handlers are not as tricky as they are made out to be. Calling them algebraic effects only increases the mystery.
A stateful handler is definitely the bit I found most tricky to get my head around.
This is my guide trying to explain how to build stateful handlers in EYG. https://eyg.run/guides/advanced-effects
I needed this to finish writing a testing framework which I hope to finish soon.

No, not that type of Agile....

With cloud-based computation now the rage, I'd like to see a language construct where I could declare methods that were "cloud eligible". Imagine code with the following method in it

promotable func MethodX(in int X, int int Y, out Z) { code }

This says "I have a method MethodX with defined input and output parameters (we'll need to have a common marshalling standard), and, this method can be transmitted Erlang-style to a defined cloud endpoint. When you invoke MethodX, it can run locally or remotely. You don't care -- that's a configuration detail.

It seems to me Erlang is almost there, but I'd like it to be a more general interface. Think something on the JVM. Serverless done right?

Rust is a clear winner in the AI era. However, it doesn't feel functional enough to spark joy.

Swift is slightly better, but still, is there anything like Haskell, SML or OCaml using reference counting and lifecycle management instead of a GC?

Here's the Github link!

The README explains quite a bit of how the code works, so I won't really go into it very deeply here. But, the gist of it is that the language only uses 8-bit hex numbers for everything.

Here is a simple "Hello, World!" program!

21 05 01 00
64 05 01 00
6C 05 01 00
72 05 01 00
6F 05 01 00
57 05 01 00
20 05 01 00
2C 05 01 00
6F 05 01 00
6C 05 01 00
6C 05 01 00
65 05 01 00
48 05 01 00

Fun, right?

If you are interested enough to try it out, please let me know what you'd like to see come to it/if there are any bugs you encounter! This is my first programming language after all, so I don't expect it to be perfect!

Thank you to everyone who gave feedback on my article about memory safety.

I used the input to vastly improve the article (see "Achieving memory safety").

Please take a look and share your thoughts again and consider starring the Seed7 project on GitHub.

I created a fun, completely normal and sane side project.

I explain how to implement a certain recursive function without the use of any recursive bindings in a tiny language called FUN. Then, I apply the same ideas to several more recursive functions so we clearly see the pattern. It begins our exploration into a certain famous combinator.

The choice to add a windowing library to the stdlib is probably controversial. I feel that the general consensus tends to be that anything related to graphics shouldn't be in the standard library. So I'm kind of interested in what people think about this.

A few years ago I made EarScript, a "simple" programming language based on brainfuck, with several additional "quality of life features" like goto statements.

Recently I've been wanting to make an evolution of that programming language and do so by incorporating a stack, as the previous language was completely tape-based in design.

I know for example lox from the Crafting Interpreters book is a well explained example, but I was wondering if there's programming languages that are closer to what brainfuck is, but based on a stack design rather than a tape design, or a register based design like some assembly languages (if I understand correctly). I think Wasm would be an example?

Are there any examples of simple stack based programming languages you'd recommend me to look into?

I can already a host a small subset of C, that can only host: "int myfunc() { return 10; } " , Which compiles to:

myfunc:

// prologue here

mov w0, #10

// epilogue here

ret

But what should I do next?

I've come across languages such as Lisp and MUMPS that feature minimal grammar and lack any reserved keywords. But is it possible to achieve this in a language with a syntax resembling JavaScript? I'm aware that JavaScript has some handy rules, like "two identifiers cannot appear directly next to each other," which could be useful. Still, can this be accomplished for every keyword?

If it is possible, how? would it rely on a fragile lexer hack, or is there a solution that scales as new language keywords/constructs are added?

Clarification: Some people are reading this as "remove all keywords from JavaScript." That's not what I mean. I want to keep if, for, while, const, function etc., all of it, as syntax.

The question is only about reserved words: identifiers the lexer forbids you from using as names. Could every keyword instead be allowed to be used as variable/class/function/module name or atleast be contextual?

Since calling the syntax JS-like comes with its own nuances. I will also clarify on that part:

1. Assume the language does not have "automatic semicolon insertion" and semicolons are mandatory as statement terminators.
2. Assume the lexer is white space sensitive and produces different tokens for -5 (UnaryMinus, NumericLiteral(5)) and - 5 (Minus, NumericLiteral(5)) and that improperly spaced forms like 8 -5 produces error for the sake of simplicity. Otherwise forms like if(x) -5 may be parsed as if(x) - 5 and cause further unnecessary problems.
3. Using a keyword as an Identifier may or may not limit the functionality of the keyword in that scope. Eg. (Inside constructor of a class) function super() {console.log("hi");} super(); // logs "hi" instead of calling the parent class

Even more clarification: I will list out the different types of reserved words in javascript. Note some of the newer keywords may be contextual or reserved only in strict mode or depending on the scope.

1. Literal like keywords: true, false, null. Easiest to solve, just make them property of the window object (as done with undefined, yes null is a reserved word but undefined isnt) or make them language constants like NaN, Infinity.

2. Operator keywords:

   1. Prefix operator keywords: typeof, delete, void, new
   2. Infix operator keywords: in, instanceof, as, extends

3. is-this-really-a-keyword keyword: super, this

4. Declaration keywords: const, var, let, function, class.

5. Module: import, from, export

6. Declaration modifiers: async, function*, static, get, set.

7. Control flow: if else, try catch finally, while, do while. And return, break, continue, throw.

8. Complex cases?:

   1. switch, case, default. For context Javascript uses identifier: statement to represent statement labels, helpful in breaking outer loops.
   2. Standard for loops and for in/of loops.

Why? What am I trying to achieve?: This is mostly a theoretical question I stumbled upon while creating my own language. I know it might have downsides for developer tools and experience. I am just wondering if it's possible.

So i stumbled upon this project, the zeta programming language by roy murphy on github. It is supposed to be a next generation system programming language.

So i coudnt really find any information about this project, especially considering it has its compiler written in pure zeta, which means the project is kinda somewhat progressed to a certain point worth noting. It even has its own website, and its own package manager's website .

What left question mark to me , is the last commit was 4 months ago, barely any issues, but the creator apparently has published and talked about it in docs, with quite detail etc.

Its rather confusing for a new comer; is this project actually legit? Need smarter people who know the craft to comment

If your interested , i stumbled upon this project when another person made a new borrow checker, and his own language - also called Zeta. https://www.reddit.com/r/rust/comments/1x1iapz/zetas_borrow_checker_the_nextgen_model_for_borrow/

I cant post any github link because apparently automod tags it.