nimforum mirror - Looking for collaborators!

nocturn9x (orginal) [2020-09-29T18:26:08+02:00] view original

Hi all folks!

I'm writing this because I'm looking for collaborators for one of my side projects, it's a bytecode virtual machine for a (currently) toy language that I've been developing lately following an amazing book available for free at craftinginterpreters.com, you may find more technical information about the project at https://github.com/nocturn9x/japl (the name might need improvements). I'm currently seeking for people to help me because I'm not as good as some members of this forum with the language (Nim) and because I'm sure it will boost my motivation as well as skills to collaborate with someone else, so feel free to apply!

Thanks in advance for having took your time to read this far and sorry for the wall of text, I hope this doesn't bother anyone

If you're interested you can contact me via email at hackhab@gmail.com or via Telegram using either @GiambyBot or my direct account @nocturn9x

mratsim (orginal) [2020-09-29T22:39:13+02:00] view original

Big projects like this are always hard to approach. You should have a small guides of areas were people can contribute and how they can get started say:

parser

code generation

test cases

examples

nocturn9x (orginal) [2020-09-30T10:13:23+02:00] view original

Even though the project is not as big as it seems, you're definitely right. If I had to pick one thing thta I desperately need help with I'd surely choose the VM. The compiler and lexer are just fine.

Would you be interested in collaborating?

mratsim (orginal) [2020-09-30T11:36:16+02:00] view original

I can review PRs of VM implementation, for VM design (as in what opcodes to choose and what do they do) I'm probably not experienced enough compared to people who worked on Nim VM.

For implementation if that can help:

Extensive research VM optimizations https://github.com/status-im/nimbus/wiki/Interpreter-optimization-resources

CHIP-8 Interpreter (Register-based): https://github.com/mratsim/chirp8/blob/91f737d8/src/cpu.nim

Brainfuck VM (stack-based): https://github.com/mratsim/photon-jit/blob/ef195440/examples/ex02_nojit_brainfuck_vm.nim#L12-L61

Jit compiled Brainfuck VM: https://github.com/mratsim/photon-jit/blob/ef195440/examples/ex02_jit_brainfuck_vm.nim#L23-L85

Ethereum VM implementation for blockchain smart-contracts (Stack-based): https://github.com/status-im/nimbus/blob/a105de1e/nimbus/vm/interpreter/opcode_values.nim

SNES / 6502 emulator (Eternal WIP, register-based): https://github.com/mratsim/glyph/blob/8b278c5e/glyph/snes/opcodes.nim

Unfortunately I don't even have enough time for my personal projects so I can realistically only do reviews and obvious fixes.

nocturn9x (orginal) [2020-09-30T11:47:34+02:00] view original

These resources are amazing, thanks! Let's hope this thread gets noticed enough so that I can find helpers haha

snej (orginal) [2020-09-30T20:19:26+02:00] view original

If I had to pick one thing that I desperately need help with I'd surely choose the VM.

I've implemented two bytecode-based VMs. (Once ages ago in Pascal, and then this year in C++.) They're not as intimidating as they seem, especially if you've got a good book like the one you're using.

The basic steps are:

Define the value type — usually this is an enum that covers all the data types in your language.

Define the operations you need — for a stack machine this starts with "push a constant value", "pop", "add", "subtract", "call", etc.

Create an enumeration listing the instructions, with byte values.

Create a "code" type that contains an array of instructions plus side tables for storing constants.

Write an inner interpreter loop that reads the next instruction from the code, dispatches it with a switch statement, and then fill in all the cases.

(I know this must sound kind of like that Monty Python "how to play the flute" sketch, but hopefully this shows how to start breaking it down into smaller problems!)

nocturn9x (orginal) [2020-09-30T22:04:09+02:00] view original

Thanks for your effort! This answer is really appreciated, but the project is now at a status where it already has a working implementation of some features and a very important one (function calls) is broken and I don't know how to fix it, I even identified the problem but couldn't solve it, maybe I should expose it here?

Sixte (orginal) [2020-10-01T08:37:41+02:00] view original

With regard to https://craftinginterpreters.com, you can already find some Nim implementations of "lox" at github. The "lox" interpreter follows the design of "wren" that you evenly can find on github. The C Code of "wren" contains an efficient implementation of a VM. The performance of that VM seems to be at par with LuaJIT - pretty impressive I think. Both "wren" and "lox" preserve the environment - allowing for implicit closures (a basic principle of Lua and the Scheme language).

nocturn9x (orginal) [2020-10-01T09:20:03+02:00] view original

I know! I already took inspiration from them, but none of them is complete (or they implement a tree walker interpreter which is not what I need). My main goal here is to have fun with some other people that like programming languages like I do

Sixte (orginal) [2020-10-01T10:28:13+02:00] view original

Well, "lox" is a toy project. If you want do have float and int distinct, then you should extend the "wren" VM accordingly. But if you want something more flexible (and fast at the long run) , then you should go for a JIT VM (look at mratsim's "laser" on github...). If you think that Nim is a good language to implement a new language project, then you are on the right track certainly. Take a look at the "Haxe" project too and implement the Haxe VM in Nim (the static part). Even if your language will start as a toy project, it should offer something new. E.g. the compiler should be able to (pre)compile code and to work with it on the AST. Your compiler should be extremely dynamic at compile time but still keep the executable as static as possible. Run-time-types and Compile-time-types, offering something in the direction of quantitative type theory. Efficient models for closures/inlining, read this: https://ix.cs.uoregon.edu/~pdownen/publications/scfp.pdf

drkameleon (orginal) [2020-10-05T11:08:52+02:00] view original

Well, since you are interested in VMs and programming languages development, let me point you to my own programming language (Rebol-inspired + stack-based VM) - also written in VM, with a solid system library included.

The project is not huge (roughly 7-8k lines), but growing. Also, the language is 100% working (I've already been using it for personal projects, although I doubt it if anybody else has used it at all... lol)

So, if you're interested in having a look, here you are: https://github.com/arturo-lang/arturo

mratsim (orginal) [2020-10-05T12:26:37+02:00] view original

@drkameleon glad to see you're back!

So VM channel on discord? So many people doing VM, custom languages, interpreters in Nim :).

Yardanico (orginal) [2020-10-05T12:28:47+02:00] view original

I feel like making different channels specifically for different categories can be good, but not if we have 20-30 of them :)

nocturn9x (orginal) [2020-10-06T07:54:55+02:00] view original

Maybe a name like "Language Hackers" would be more appropriate? :)

mratsim (orginal) [2020-10-06T09:59:58+02:00] view original

vm ~ virtual machines covers:

virtual machines

emulation including old CPU/console emulation

interpreters

assembly/assembler

languages built on top of Nim

but otherwise virtual-machines or interpreters might be the best.

ElAfalw (orginal) [2020-10-06T10:52:43+02:00] view original

Well, count me in!

I guess there are many people far more knowledgeable than me in this field, but given that I've been playing with interpreters/compilers/grammars/etc for the past 15 years, I hope there is something that I can contribute. :)

And, yes, in that aspect, Nim seems like a perfect choice. I had initially written Arturo in D, then I switched to C, and then I started looking for an alternative: basically, something that would keep C's strengths, but rid me of C's headaches. And here Nim definitely shines. ((I then made another attempt to switch back to C, but that's another story... haha I guess I'll stick with Nim)

nocturn9x (orginal) [2020-10-06T14:36:50+02:00] view original

Hopefully I'll be able to find collaborators for my project there :')

haxscramper_ (orginal) [2020-10-07T13:40:19+02:00] view original

Another option is language-development, since not all languages are interpreted, not all of them have VMs etc. There is already several different languages implementations (in addition to other lings in this tread)

https://github.com/Yardanico/nim-lox

https://github.com/gokr/spry

https://github.com/nocturn9x/japl

https://github.com/arturo-lang/arturo

make a lisp implementation in nim

and of course nim-lang itself

This also might help to offload some of the compiler-related discussions from #main in separate channel so things won't get mixed so much (i.e. beginner questions together with RFC/issue discussion and so on).

drifter (orginal) [2020-10-09T13:34:16+02:00] view original

As a sidenote, there are already a number of Lox implementations written in nim. A quick search:

https://github.com/Yardanico/nim-lox https://github.com/cabhishek/nimlox

I'm sure there are more.

Perhaps these can inspire and motivate you.

Also, you might be interested in:

https://www.objectpascalinterpreter.com/home

Which walks you through the same process, but using object pascal. Book #2 goes through implementing the bytecode VM.

Mirror of forum.nim-lang.org

6871 :: Looking for collaborators!