I'm creating a host-embedded, minimal, beginner-friendly programming language as a replacement for Lua. This language is really human readable, English-like and beginner friendly, with automatic memory management, automatic parallelism, a fantastic and helpful compiler inspired by Rust, and other things. The biggest question I have is whether I should choose 1-based indexing or 0-based indexing?

Hi everyone! I'm a 13-year-old developer. I've been working on my own programming language called Begamix.

What is it? Begamix is a compiled language that transpiles to C++ and then to machine code. It's designed for writing fast bots and network servers.

Key features:

· Compilation to C++: Uses clang++ under the hood to create native binaries. · Custom epoll runtime: Has its own event loop with a worker pool for handling Callback API requests. · Custom Garbage Collector (SGM): A modular GC that makes multiple passes and protects against deleting needed objects. · Native HTTPS sockets: Sends messages to Telegram and VK directly, without curl. · Simple CLI: Just run ./begamix run your_code.bgmx and it builds & executes.

I built this because I wanted a language that is as fast as C++ but easier to set up for bots. The syntax is a bit unusual (uses << >>), but it works!

Why I'm sharing this: I'm not here to just drop a link. I want to know what you think about the architecture. How would you improve the Garbage Collector? Is the epoll implementation solid for a bot runtime?

I'd love to hear your feedback and ideas! 🤝

I was watching tsoding's crust stream and I thought it would be so funny if I extended c to have generics.

The way I did this was by extending the syntax of c with the classic rust angle brackets to define generics and then during transpilation do some name mangling to monomorphize the generic code.

Here is the result of that abomination:

#include <stdio.h>

// you can define your own operator in fortran .op. style with a trait
trait<T> DotP {
    // for parsing reasons any dot-op must have whitespaces around it in any context
    T .dot. (Self self, Self other);
}

// using a very similar syntax to rust, you can add generics to structs
typedef<T> struct {
    T x;
    T y;
    T z;
} Vector<T>;

// and by appling the trait to your struct (with generic parameters)
// you can define what your operator should do.
impl<T> DotP<T> for Vector<T> {
    T .dot. (Self self, Self other){
        return self.x * other.x + self.y * other.y + self.z * other.z;
    }
}

int main(void) {
    // by concretly defining which type you want to use as the generic
    // a c struct with that/those type(s) is genenerated 
    Vector<float> fv = {1.0, 2.0, 3.0};
    printf("Dot product of fv^2: %f\n", fv .dot. fv);
    Vector<int> iv = {1, 2, 3};
    printf("Dot product of iv^2: %d\n", iv .dot. iv);
}

The generated c code looks something like this (I have actually implemented this transpiler, perhaps a true indicator of joblessness):

/* Generated by typedc. */
#ifndef TYPEDC_SIMPLE_GENERICS_H
#define TYPEDC_SIMPLE_GENERICS_H

#include <stdio.h>

typedef struct float_Vector float_Vector;
typedef struct int_Vector int_Vector;

struct float_Vector {
    float x;
    float y;
    float z;
};

struct int_Vector {
    int x;
    int y;
    int z;
};

int main(void);
static inline float float_dot(float_Vector self, float_Vector other);
static inline int int_dot(int_Vector self, int_Vector other);

int main(void) {
    float_Vector fv = {1.0, 2.0, 3.0};
    printf("Dot product of fv^2: %f\n", float_dot(fv, fv));
    int_Vector iv = {1, 2, 3};
    printf("Dot product of iv^2: %d\n", int_dot(iv, iv));
}

static inline float float_dot(float_Vector self, float_Vector other) {
    return self.x * other.x + self.y * other.y + self.z * other.z;
}

static inline int int_dot(int_Vector self, int_Vector other) {
    return self.x * other.x + self.y * other.y + self.z * other.z;
}
    
#endif /* TYPEDC_SIMPLE_GENERICS_H */

This might sound like a super dumb question, but I did not want to ask Chat gpt and I wanted to ask an actual human,

but why if the first for a church pair , like has this abstraction

λp. p true 

and not just true.

Is it because its supposed to like take a pair as an argument and spit out the first , and thats it? cause if it were just true it would still behave the same

sry for the dumb question lol

I think I need to write a blogpost about why I deliberately nerfed dependency fetching. Why it's `c3c project fetch raylib sdl3` and not just `c3c project fetch` when the project has enough information to get them automatically.

I recently just dropped raw-pointers in my interpreted language in favor of a path-based reference type which always gives `none` if the path ever becomes invalid, unlike a pointer which would cause unexpected issues or crash the program.

Now my question is... am I missing out on anything by eventually removing the pointer type entirely? In a sand-boxed language like Ity where everything is tightly controlled & you cant really access the underlying memory of anything, does it make sense to keep pointers to values? Doesn't a path do everything you need it to? You can access storage cells just the same but it's just safer, or am I mistaken.

The idea here is to make a truly 100% memory safe design, so that you couldn't corrupt or mess with the memory even if you wanted to, but you also get to pass around references to values (which is rather required for a language that has a strict copy-everything rule).

Let me know how you would go about designing a system that can pass around references while maintaining an unbreakable wall between the program & it's memory. The way I handle it is very simple, you can only reference values that are stored as a variable somewhere or is a variable nested somewhere inside some container. This means things like temporary values cannot be referenced as they have no storage cell, which I believe is one difference between path-refs & pointers.

Another big part of my design is that everything is copied, everywhere. Passing an argument to a function copies the value, setting a variable to another one also copies the value, no matter the type. You must explicitly use a "ref" type if you want to avoid unnecessary copies. But acknowledging this, I made refs very convenient to work with. By this I mean assignment operators, arithmetic, & method calls all act on the referenced value, not the actual ref itself, making it seamless to use effectively. Of course you can still inspect properties of the ref using it's own type methods.

So yeah, that's how I went about the design of a memory safe language with simple & intuitive references. I am curious to see how your guys' *interpreted* languages went about solving references & memory safety, so do let me know of interesting alternative methods!

Pretty much all successful general-purpose programming languages were thought of by someone with a particular use-case in mind, or even just one particular use. They became successful because in trying to do whatever-it-was really well, the authors hit a larger target than they aimed for, and the more successful they became, the more this is true. Some examples, in alphabetical order:

• C was designed solely to write UNIX in. This is the poster-child for "hit a bigger target than they intended". Besides C's other merits, it came out when (a) fine control over memory and clock was important even if you weren't doing systems programming (b) the users were the sort of l33t geeks who were quite happy to stay up 'til 4 am chugging Mountain Dew and swearing at malloc in exchange for an inner loop that goes brr.

• The C++ origin story is that Bjarne Stroustrup was trying to model computers interacting in a network, and wrote a beautiful version in Simula which would take a hundred years to yield enough data; followed by an ugly version in C which was performant --- and wished, naturally, for the best of both worlds.

• Erlang (the surprise sleeper hit of languages, now the basis for Elixir and Gleam) was designed to make Ericsson's telephone exchanges more stable.

• We all know what JavaScript was designed for. It works for that, and has now been used for everything else. JavaScript is something of a special case of course, because of its association with web-browsers, but we should consider that for example Java applets failed at the same task, along with ActionScript, VBScript, JScript, Silverlight and NaCl.

• Fortran was invented to do big math and science fast. Fortran would be supplanted by later languages (C, obviously) for everything but its core competence, but before then it was used for the first adventure game, for payroll software, chess engines, CAD, mainframe utilities, and self-hosting compilers.

• Go has not unkindly been called "a DSL for writing servers".

• Haskell was invented as a platform for mathematicians to experiment with lazy functional languages, which explains pretty much everything about it.

• Lisp was invented after John McCarthy had been working for IBM on an extension of Fortran for list processing. The people at IBM were very happy with his work; he was frustrated. What he wanted, very reasonably, was to be able to automatically differentiate a function and then evaluate it, which sounds like exactly the sort of thing computers should be making easy for us. Fortran made it impossible despite its math orientation and despite the fact that McCarthy had been hired to write his own extensions to the language. The path to Lisp's homoiconicity is obvious; only slightly less obvious is why he reinvented flow-of-control as expressions. (Hint: think of differentiating a function defined by cases.)

• Julia was made for math people to do math things in.

• Lua was designed to solve the needs of scientists and engineers in Brazil's fossil fuel industry. (It became wedded to the games industry when someone at LucasFilms Games read about it in Dr Dobb's Journal and realized it was better than what they'd done in-house.)

• ML was invented as the meta-language for a theorem-prover and people who used it spontaneously demanded the language without the theorem prover.

• PHP, despite being objectively terrible, and coming from (and being aimed at) a dysfunctional "worse is better" culture, managed to spread like wildfire or a plague of poorly-designed locusts because its initials stood for Personal Home Page: it knew exactly what it was for.

• Python was created because Guido van Rossum realized that a dynamic language with powers to do OS-level things could make his life much simpler: "I thought, well, oh man, if we just could program ABC instead of C, each of those utilities would be like half a page of code and I could write the entire suite of utilities in a couple of weeks instead of the years that it looked like it was going to take us."

• Rust was famously inspired by a stuck elevator reminding Graydon Hoare of how terribly often things break, a rather more "meta" inspiration than for example C's origin story but still a moment that gave Rust a fixed purpose.

And then there's the obvious outliers:

• Java's original use-case was embedding into consumer electronics, at which it failed, so to rescue the project it was pivoted into powering "applets" (embeddable client-side applications to be embedded in HTML), at which it failed, and then it became the giant among languages that it is today because Sun Microsystems spent a billion dollars on advertising to persuade Business Idiots that this was How To Do Business Properly. There should be a law against marketing technical solutions directly to management just like there are laws against marketing cigarettes to children but what do I know?

• C# is Microsoft Java.

• Kotlin is Java redesigned by people who hated Java but didn't hate it enough.

Some things worth noting:

There are two kinds of programming languages, those written for the author, and those written for other people. And in the second case, the other people are always dumber than the author, who is talking down to them. BASIC wasn't designed because Kemeny and Kurtz needed BASIC. BASIC was designed because Kemeny and Kurtz thought that liberal arts graduates needed BASIC, because what would make things simple for their muddled little heads is a language where all values are passed by mutating global state, which is like having a bicycle for beginners where instead of having training wheels you douse it in gasoline and set it on fire.

So you will notice that none of the things on the list that are used as easy languages for n00bs were designed for that. Python was designed for Guido van Rossum to do systems programming. Lua was designed for engineers and geophysicists. JS ... * gestures broadly at the internet *. They were designed, in fact, to be ergonomic for clever people to use, and it turns out that exactly the same things make languages ergonomic for everyone to use, and that more people are clever than was previously supposed, including liberal arts graduates.

(The fact that > 50% of indie language projects are "C/C++ but better" is because the indie langdevs are all trying to scratch the same itch, they're all trying to write the systems language that they wish they could code in. These are languages written for the authors, where the authors are all very similar people who want similar things.)

The other thing that leaps out at me from my list is that the "classic" functional languages, the Lisp and ML families and Haskell, all came from math people wanting to do hard math things as their paradigmatic use-case, and anyone wondering why functional programming hasn't conquered the world yet should think about that.

(I of course have been thinking about that, and although it is premature to put Pipefish in an article about successful languages, making an FPL for writing CRUD apps has produced an language that hits different, and which can in fact be used for all sorts of cool things besides that. Watch this space for the announcement of my front-end web framework.)

It appears that r/PostScript is truly dead. But I just have to talk about this PostScript stuff I've been playing with.

So, a closure is of course a function plus an environment containing the bindings of its free variables. PostScript has all that! A procedure is just an array with the executable flag set, so it can carry its own storage. It doesn't even strictly need variables because you can embed a circular reference so a procedure can access its own array as storage.

But then you can't print them out. If the procedure contains a circular reference to itself, then calling == or pstack will give you an execstackoverflow error.

So, instead we can pack the variables in a dictionary. This example generates a pseudorandom number generator using an environment dictionary.

%!
/start { 1 dict begin } def
/args { { exch def } forall } def
/clone { dup xcheck exch dup length array copy exch {cvx} if } def
/prng { {seed} start args
  /env currentdict def
  /func ({//env/seed get
          dup -7 bitshift xor
          dup 9 bitshift xor
          dup -13 bitshift xor
          //env/seed 2 index put}) cvx exec def
  /func load end
} def

Poof! a closure. seed prng generates a generator starting from that seed. You can just straight up make a copy of it at any point to have 2 synchronized generators if you wanted that. You can even see the environment and how it "captures" arguments (collect them in a dict, duh. then save the dict). It all seems so simple now. But I don't recall seeing anybody else do it.

I'm making a programming language, it's based on Luau and C++ and its called L++! however im having some issues implementing diagnostics since they dont technicallly stop execution, but some of my code has typescript type errors since it relies in, stopping execution! for example normally this would work:

function foo(param: someUnion): someType {
    if (someUnion.type === "coolType") {
        return someTypeValue
    } else {
        throw new Error()
    }
}

with diagnostics:

function foo(param: someUnion): someType {
    if (someUnion.type === "coolType") {
        return someTypeValue
    } else {
        //error since not all paths return someType
        reporter.report(new Diagnostic())
        
    }
}

i'd like to know how to fix this, and/or if there are any established ways to do diagnostics, thanks in advance!

Hello everyone,

I'm an independent french developer working on an experimental programming language called PLUSHIE, and I'd like to discuss an idea behind its design.

I am new to this communty and I am not familiar with the expected behavior here, so do not hesitate to tell me if I am wrong.

I also apologize for my english whcih is far from perfect.

Most programming languages rely on explicit syntactic delimiters: parentheses, commas, spaces, operators, keywords, etc.

I've been exploring a different approach: what if a language could rely primarily on the recognition and sequencing of a small vocabulary of words?

In PLUSHIE, the parser scans the input and identifies known words. Their sequence determines how instructions are interpreted. Unknown text between recognized words can also become new vocabulary.

The underlying computational model is deliberately minimal. Instructions operate on a chained memory structure, and the language is designed so that its own structures and interpretation mechanisms can be modified while running

This raises several questions I'd be interested in discussing:

o How expressive can a language become without conventional syntactic delimiters?

o What are the fundamental limitations of a word-based parsing model?

o Could such a design offer interesting advantages for reflection and self-modification?

o and especially, Are there existing languages or theoretical models that explore similar ideas?

I'm not claiming this is a better approach than conventional syntax. I'm interested in understanding its possibilities and limitations.

PLUSHIE is an ongoing experiment, and I'm particularly interested in unexpected ideas, alternative approaches and constructive criticism.

What do you think? Is this a worthwhile direction to explore, or am I overlooking some fundamental difficulties?

I have been more frustrated lately with languages developing a "kitchen sink" attitude to paradigms. I am finding code less uniform, and therefore less readable.

As I am developing a new language, I wanted to know from you all:

What languages that aren't "big", do you find the most readable? Are there any that come to mind that take a genuinely unique or interesting approach to how the language looks to write?

It's been 4 months of on & off development of my C++ interpreted programming language built from scratch; Ity. For the longest time my plan has been to only have *two* number types, of course being a standard 64-bit signed & a 64-bit signed floating point. I thought that would be sufficient, sometimes I wonder if it still is all I really need.

This past week I decided I would implement these additional integer types: i32, i16, i8, u32, u16, & u8. My reasoning? I simply wanted more options for numbers, a higher capability for explicit specification. The more narrow integer types don't provide better performance & hardly any memory advantage with my current polymorphic design. It is simply there as a convenience, you don't need to use it, you rarely get a benefit for using it, but it's there.

Now for any old language it would be fine to keep these in even if they served little to no purpose. But here's the thing, I am aiming to make this language as compact as possible while still being (in the long run) readable & easily understandable just by looking at the source code. So what's the real trade-off here for all the logic required to implement multiple integer types, all the casting & operator logic between each type... The cost is about +18kb in final binary size. Is that acceptable?

Am I better off just dropping the idea for the sake of being as small as I can get? For reference, without compression & excluding the new integer types, the binary is 130kb. With compression 65kb (including new int types, ~50kb without).

Do I continue building around these extra types, improving their usefulness (I.e. actually reduce memory usage according to the type) to justify the addition? Is this something you would be able to live without in your primary programming language?