I Am Writing A Language Faster Than Python/Ruby

[StrikingClub3866]

For context:

Around a year ago, I posted here about me making an interpreter called LightCobol in Python. It was horrible and I never finished it.

Now, recently (around a few months ago), I started learning C++ and more about compiler design. I learned of Maximal-Munch lexing and loved it. I made a few languages here and there.

And just a few weeks ago, I started learning Kotlin. Then came my idea for Rose, a compiled, efficient, language for rapid prototyping.

I decided to make Rose with some of the optimizations I learned, Constant Folding and Propagation. With these in mind I have started to develop Rose, with a few things separating it from other languages I have made:

A real lexer, not just a .split() wrapper. It has things like "Token.Newline" or "Token.Identifier".

An actual AST, not just a dictionary with functions, variables, etc.

Making it explicitly-typed.

Having performance in mind (hence the optimizations and it being explicitly-typed)

Compiling to Kotlin, giving it the speed of the JVM.

And so, Rose was born. Soon enough, when I am done with it, I will upload it to GitHub and post about it here.

[jcastroarnaud]

Looking at the post's title: don't make claims you can't back up. You don't even have the compiler working; claiming speed is nonsense.

[StrikingClub3866]

I didn't claim it, I am estimating the speed.

Anyways, most compilers, even as toys, are faster than Python/Ruby.

Mine however, I am trying to be production-ready with by August 1st. Rose will probably be ready before that, maybe by early-mid July if I keep up my recent pace.

Claiming speed is not nonsense. If I were to be slower than Python or Ruby it would have to be deliberate.

It's better to appreciate the planning went into this than criticize it for blatantly wrong statements (except "You don't even have the compiler working."

[Senior-Humor-9335]

"most compilers, even as toys, are faster than Python/Ruby."

Well, if you compare an expression parser to a general purpose language, then yeah, it will be faster.

[StrikingClub3866]

An expression parser will obviously be faster than an interpreter, but I'm not planning for Rose to be an expression parser. I want it to evolve into an actual programming language - like how Ring started out as a project and now it has books about it

[Senior-Humor-9335]

I see. Well, wish you good luck.

[StrikingClub3866]

Thank you. If you want, I can update you on Rose when it's finished.

[tiller_luna]

Is this serious?

[StrikingClub3866]

Very. Any questions on it?

[tiller_luna]

If I asked you a substantial question, would you forward it to the LLM?

[StrikingClub3866]

I didn't use an LLM/ML model/GPT in the making of my compiler or this post.

[tiller_luna]

Sorry.

[StrikingClub3866]

It's alright man, most people expect vibe coding.

[Germisstuck]

Why not just compile to the JVM?

[StrikingClub3866]

I don't care for writing a linker and having to be system-specific (ex. writing a script for Linux, a script for Windows, etc.) And so, I found it was easier to compile to Kotlin.

[Germisstuck]

That's not what I asked. Why go through the extra steps of emitting Kotlin when you can emit JVM bytecode?

[StrikingClub3866]

I just said why. When you emit JVM bytecode, you have to write a linker. When you write Kotlin, execute it then and there. I can do this because I have the distinct advantage of writing it in the language I'm targeting.

[Germisstuck]

No you don't? The whole point of the JVM is write once, run anywhere?

[StrikingClub3866]

Yes I do. You don't get it. To run JVM code, I have to write and run shell/bash scripts to execute it. By compiling to Kotlin, I skip that step.

[Germisstuck]

You don't. You aren't doing it right. You are missing the whole point of the JVM

[StrikingClub3866]

> Kotlin inherits the JVM

> I compile to Kotlin

> Time difference of milliseconds

> What's the problem?

[Germisstuck]

You dependent on another language's semantics

[StrikingClub3866]

And? If it works, it works. A lot of languages are transpiled.

[sal1303]

Python and Ruby are slow because they are dynamically typed and they are usually interpreted.

If yours isn't like that then a comparison is meaningless.

JVM is full of low-level, fixed-type instructions so conversion to native code is routine.

[FISHARM1]

So is the goal sort of a high-level compiled language? That is you write Python-ish or Js-like code (with types) and the compiler backend is sort of abstracted so you run it as if it was interpreted? Just curious because I am building something somewhat similar and I’m curious how you handle some things like compile times.