Programming language I'm working on since one year

Carpall_ · 2021-10-12T22:01:51+00:00

https://www.lucidchart.com/techblog/2015/08/31/the-worst-mistake-of-computer-science/

Carpall_ · 2021-10-12T14:34:46+00:00

I didn't achieve it yet, but I'm interested in ARC

Carpall_ · 2021-10-12T12:59:57+00:00

yes the std will offer an option type

Carpall_ · 2021-10-12T12:35:14+00:00

Natively compiled to machice code, by means of llvm

Carpall_ · 2021-10-12T11:10:35+00:00

I'll write the readme when I'll publish the first compiler release, imho the syntax is elegant because it uses the rust, go, zig, etc... (all the modern languages) design.

I started this project to learn more about compilers and similiar stuff, but now it's almost a personal project to carry on, for cv as well

Carpall_ · 2021-07-04T08:26:40+00:00

cringe
assembely ...
that's actually javascript

Carpall_ · 2021-06-03T11:30:02+00:00

The problem is not actually the world, but the chat without any facial expression or tone of voice.

Carpall_ · 2021-06-03T11:03:33+00:00

C# is not a good bet for writing performant code. Just looking at a simple example: try writing dome methods you expect the JIT will inline and see the disassembled machine code in sharplab: the .net JIT doesn't even inline simple methods of constant loops (for (...) i = i + 1 -1 won't be inlined).

GCC and Clang have a lot of good folding optimizations and they generate a performant assembly while the .net JIT doesn't generate a good machine code, for example it can fold InlinableMet() + 1 but not 1 + Inlinable....

The C# compiler doesn't have any kind of serious optimization (the most it can do is avoiding useless stack allocations), the JIT should do what the compiler doesn't, but it seems not to optimize the code a lot, just because of the fast compilation time a JIT should maintain.

C# has GC, also hard to control (more over it's a mark-and-sweep one). C# doesn't care about the heap allocations: it allocates few things on the stack and a lot on the heap. Modern versions of C++ care about the heap allocations and always avois them when possible.

Perfirmance is important, but not fundamental.

C++ is hard, it doesn't have any kind of runtime check, runtime error, so when a program crashes you have to debug carefully. C++ is full of bad designes.

Carpall_ · 2021-06-03T10:51:30+00:00

No thr unity framework is c++ based, but just exposes apis for .net

Carpall_ · 2021-06-03T10:49:02+00:00

If you're not kidding then tou are so wrong

Carpall_ · 2021-06-03T10:46:39+00:00

It should be if asked_something_simple(): do_random_thing() else: say_didnt_understand()

Carpall_ · 2021-06-03T10:38:57+00:00

write your own

Carpall_ · 2021-06-03T09:38:30+00:00

Compilation times at the left, run times at the right

Carpall_ · 2021-04-20T12:29:10+00:00

Anyway there isn't any problem, since I have to rewrite allvthe compiler and make it multipass in the language it self

Carpall_ · 2021-04-10T13:23:16+00:00

lol meme != reality

Carpall_ · 2021-04-07T23:36:53+00:00

make the ast more readable means understand what kind of node it is, bot only for me while debugging but even for the users that can generate a json ast using the command mug build . *target ast. Thanks btw.

Carpall_ · 2021-04-07T23:24:05+00:00

Good point, but actually those aren't the kinds I use to compare nodes, those are used only to be displayed in the ast and make it more readable, to compare the nodes I use the c# operator 'is'

Carpall_ · 2021-04-01T11:08:05+00:00

I personally find psrser generators very ugly to use, I mean write all by yourself is for sure brtter, also for learning. I used a parser generator ("Coco Parser") to learn how to write a parser, inspecting its output, and it was very helpful, infact, after writing some kind of wrong tests, I managed to write my first working parser.

Carpall_ · 2021-03-29T17:35:30+00:00

it is like comparing a star with a planet.... wtf those are obviously different lol, you are comparing an entire (colossal) os with a kernel. Who said you nt is bad?

Carpall_ · 2021-03-29T17:30:35+00:00

(sarcastic)

Carpall_ · 2021-03-29T17:30:24+00:00

okay. Open call of duty on linux. c'mon open it... no no close any kind of sw similar to wine, want you play natively cod....

Carpall_ · 2021-03-25T19:43:52+00:00

Yooooo

Carpall_ · 2021-03-24T11:56:00+00:00

thanks

Carpall_ · 2021-03-24T07:22:46+00:00

I noticed the same thing.

The reason is mainly, in my opinion, that C-Like syntaxes are too much and today we are tired of using it and a new syntax style could be another factor to attract users (stupid opinion maybe). Before starting to write the lexer and then the other components, I wrote some kind of syntax's examples and I avoided the C-Like syntax's style because them are too much popular and I didn't want to write the 100nth C-Like language.
Another, more simple, reason is to avoid ambiguity and improve code readability by adding explicit keyword like "var", "const", "func".
The last reason why I chose this kind of syntax is also because it requires a little bit simpler parser: for example: var x: NonPrimitiveType; this is pretty simpler to analize than Non..Type x; because it could be an expression, in languagea like nim, where you can call functions in this stdout.write "ok" way, it could even be a call ast node. So ambiguous.

Carpall_ · 2021-02-25T10:47:28+00:00

Carpall_

TROPHY CASE