r/ProgrammingLanguages

Is there alphabetic list of desing flaws/bad ideas in various programming languages?

For exampe you might find short description of dangling-else from under d letter in list.

I wrote a beginner-friendly blog post about Pratt parsing, hopefully it can help more people understand it. This is actually what I wanted to see when I was learning it; when I was reading Bjarne Stroustrup's book on C++ he also builds a little math parser and it is really simple to follow. The code for the full project is also available at the end of the post under the citations.

How would you feel about a language that has a borrow checker with a prototyping mode for rapid iteration? In this mode, proper annotations would still be required (failure to do so would result in compile errors) because the compiler still needs that information to reason about lifetimes, but violations of the rules themselves would result in warnings. Compiling in safe mode would be just like Rust, resulting in errors.

Do you think this would meaningfully improve iteration times for domains which require it (game dev, for example)?

Would this defeat the purpose of a borrow checker, in that most would follow the path of least resistance and not bother to clean up after themselves, resulting in an ecosystem of unsafe libraries?

Imagine you start with the C language and then make the following changes:

1. Remove pointer arithmetic. You want an array, you declare an array.
2. Change the compilation of string and array literals to emit a length prefix.
3. Rewrite the entire standard library so that all string and array functions enforce a length header in front of the data.
4. Add RTTI to all unions and varargs so that incorrect casts fail rather than UB.
5. Remove `void *`.
6. Forbid malloc() without static compile-time verification that the matching free() exists (with some sort of Bounded Model Checking to sidestep a rather inconvenient Halting Problem).

Is such a language possible?

Has it ever been attempted?

Since few days, I have been working on a compiler written in python. I have successfully implemented a frontend and I want a backend to generate IR for. I have decided to make my own IR but I don't know a lot about them. Can y'all please provide me with information with types of IR, optimization tricks they utilise, and how they are implemented or work. Any type of material will be thankful.

Hi all,
apologies for my inexperience, I'm not formally trained in CS.

I'm writing a small programming language to play around with some ideas, and I've come to the point of implementing constants folding. While doing so, I realized the AST token I use to group binary operators could probably be split in 2 different tokens instead: one for operations that return the same type of all the inputs (like addition/multiplication/etc: `add(a: T, b:T) -> T`) and one for operations that return a different type (e.g.: `greather_than(a: T, b;T) -> bool` and friends).

Out of curiosity, is there a specific name for a function whose output type is the same as the type of all its parameters ? It would help me name those 2 different categories appropriately.

I want to include compile time evaluation in my language.

For context I have most of the language design and compiler planned out and am currently implementing it. Currently writing the parser that turns a stream of tokens into the ast. The plan is to target llvm ir for the moment.

While I have enough to do before I have to address it I want to get some information about executing code at compile time. I am explicitly not talking about macros for them I already have an idea. My questions are:

1. How to decide rather to execute a function or keep the call in code

2. Security concern about access to the system on compile time evaluation

3. How to execute it without writing a separate interpreter

4. Does llvm provide any supporting features for this

Thanks

I had a light bulb moment last night and I'm embarrassed I didn't think of it sooner because its used in so many other languages. I realized lots of things could be desugared into simpler syntax (not IR). But the more I think about it, the more it seems not-so-straightforward.

Consider:

fn stuff(likesFemBoys = false) {
    // Stuff
}

We could avoid a "DefaultParam" Node by turning the function into

fn stuff(likesFemBoys: Bool) {
    likesFemBoys = false;
    // Stuff
}

But, depending on how a language is implemented, it raises some issues. If your language doesn't allow parameters to be implicitly mutable, you'll need to use a temp to work around it. Something like:

fn stuff(likesFemBoys: Bool) {
   let xx_default_likesFemBoys = false;
   // Stuff
}

Well now you have to use xx_default_likesFemBoys everywhere likesFemBoys is used. And, you have to ensure that no user defined identifier can start with xx_default_. It feels a bit ... hacky?

You could defer doing all that till you get to IR and have the DefaultParam Node in your AST. But, all the previous stages will have to explicitly handle the sugared nodes (there's typically a lot), when we could have desugared them earlier and keep everything consistent and simpler.

But if you desugar them earlier, you might have to do workarounds like what was described above. Error messages could also become trickier to get right.

Another example is handling nulls. E.g. as seen in other languages

let name = findName() ?? "NoName";

Which might be desugared into:

mut tmp = findName();
if tmp == null tmp = "NoName";
let name = tmp;

When would be appropriate to desugar this? Would you create an AST node for it? Or simply parse it as an assignment statement, if statement, and another assignment statement?

I wanna make a language for my Undergraduate Thesis, I guys know any place that have something like a tutorial or roadmap to make one? I just found a person talking about analyzers

Most runtimes used by AI agents today are designed for humans, not disposable AI-generated code.

I’ve been experimenting with a small scripting runtime called Autolang focused on:

• low startup latency,
• strict static restrictions,
• restartable arena memory,
• opcode execution limits,
• and lightweight orchestration around existing ecosystems (Python/C++/JS).

The goal isn’t replacing Python, but creating a safer intermediary layer for short-lived AI-generated scripts.

I’m curious whether people here think this direction makes sense for modern AI-agent systems, especially compared to approaches like Wasm, Lua, or sandboxed Python.

I’d also genuinely appreciate feedback on runtime/compiler design and possible performance improvements if the project sounds interesting.

OP here. I'm trying out a new interactive way to teach complex concepts. What do you think of the style? How about content, could you follow along okay?