the-super-tiny-compiler VS javascript-algorithms

Now, those concepts are a whole entire world to explore, and this is out of the scope of this article. I suggest the reading of the Chapters 4, 5 and 6 of the book Crafting Interpreters by Robert Nystrom for a wider (but still practical) understanding of those subjects. Another practical great resource to look at is The SuperTiny Compiler. To explore them from a theorical point of view, you can find A LOT of resources from books or courses online.

The super tiny compiler by Jamie

I am currently writing a much more intricate version of the Super Tiny Compiler (https://github.com/jamiebuilds/the-super-tiny-compiler) in Rust, only I plan on handling many basic operations, essentially a compiler for a MUCH simpler version of Go. Great project idea btw, for anyone who wants to explore compilers. But in doing so, have really found a new respect for just what is going on when you gcc -o garbageprogram mytrashcode.c

Here, at least take this floatie: https://github.com/jamiebuilds/the-super-tiny-compiler

Outside of this, I recently learned about The Super Tiny Compiler which was a project written to be read. Mind you, it has a vast amount of comments, which may be more of a leg-up than you're asking for.

You could start here:

https://github.com/jamiebuilds/the-super-tiny-compiler

That converts from lisp-like to javascript. Really though this is a big field, and there are lots of resources out there.

To get started look at your input language; you'll need to lex and parse that. Then massage the parsed structure into the appropriate output.

You can see me convert brainfuck to C, or x86 assembly language here:

https://github.com/skx/bfcc

I'm reminded of the time when some kid wrote a script to crawl GitHub and create issues[1] about using inclusive language... except it was really dumb, for example: https://github.com/trekhleb/javascript-algorithms/pull/875/f...

[1] E.g.: https://github.com/EbookFoundation/free-programming-books/pu...

Try codewars or leetcode Or you can use this repo for ds practice https://github.com/trekhleb/javascript-algorithms

This one is pretty popular too.

for algos - not sure how much you'll need to do for a jr position but familiarity with some of the beginner stuff here couldn't hurt: https://github.com/trekhleb/javascript-algorithms

Traditionally, a linked list allows you to insert before/after a node. i.e. addBefore(node,value) (see [2] ) He doesn't implement addBefore & addAfter.

Instead, he provides a whole bunch of non-canonical helpers like reverse(), toArray(), deleteTail() etc - these are typical LC-Easy problems that don't belong inside the data structure.

My own introduction to these things was a C course called "Data Structures in C" in the traditional CS curriculum, and yes, you would have to malloc a new node, get back a pointer with a memory address, & the process of pointing the next pointer of the current node to this new node so that the memory address of the next value was explicitly "linked" to the current value and hence linked list etc...I guess much of that terminology is lost on the new generation in the absence of pointers & memory addresses.

The canonical exercise in those days was - Show that a linked list does not store objects in contiguous memory, unlike an array. So to solve this, you would traverse the list from the head node & print the actual addresses of the memory locations along the way, proving that the vals aren't stored contiguously. I wonder what that exercise would mean in JS land.

That said, yeah its a good starting point & I applaud the effort.

[1]https://github.com/trekhleb/javascript-algorithms/blob/maste...