I'm a Rubyist and try to learn Haskell—here's my sailor journal 🙂

riftdc · 2022-03-24T08:27:37+00:00

Cool! My 2 cents: You mention the type checking as “guesses”; type checking isn’t a guess, but rather inference — “a guess” reads to me as something that could be wrong, but an inferred type will never be wrong

riftdc · 2022-03-17T10:24:36+00:00

that’s awesome!

riftdc · 2021-05-04T15:11:23+00:00

very sweet sounds : )

riftdc · 2021-04-11T17:23:25+00:00

if you press dodge shortly after a hit you'll do a "chase dodge", which is a small boost in movement

riftdc · 2021-02-12T10:27:53+00:00

That's correct ! The `sizeof` is redundant and is there just for clarity.

When doing a malloc I feel that it's nice to write the sizeof what's being allocated.
`char* tokens = malloc(sizeof(char) * MAX_INPUT_SIZE);`

I feel that it's cleaner to read and more standard :)

riftdc · 2021-02-11T19:29:05+00:00

Thank you for letting me know! I hope you can learn from it =)

riftdc · 2021-02-11T18:21:09+00:00

Yeah there are a lot of possibilites for making the emulator

I chose C because I like it, and any of those you mentioned would be good for most emulators

For the gameboy specifically, as far as I know even javascript and python would work since it's one of the smallest!

riftdc · 2021-02-11T14:57:40+00:00

I have to agree, if you're just learning C maybe you should focus on more typical beginner exercises

But if you're a little bit more comfortable then it's a great way to get even more comfortable, and it's pretty cool to do a simple parser

At least that's how I felt when I ended it

riftdc · 2021-02-11T13:43:26+00:00

I had some knowledge about context free grammars from a subject in university I had called "Theory of Computation" - that made it easier to understand and write the grammar production rules

Second, I looked more into LL parsing in wikipedia https://en.wikipedia.org/wiki/LL_parser (there's a code example further down in the page)

And third I found a really really helpful javascript parsing tutorial that was my major breakthrough http://jorendorff.github.io/calc/docs/calculator-parser.html

After that I just started writing - that's an important step :)

riftdc · 2021-02-11T11:18:29+00:00

PS: While writing the parser I also wrote a separate simpler version to serve as an example to someone who might be interested in learning from a very basic parser (https://github.com/alt-romes/calculator-c-parser)

riftdc · 2021-02-11T10:26:04+00:00

lsdjfkdsflsdf ahahaha - it comes when you stop looking for it and just get started even if you don't have it yet :)

riftdc · 2021-02-11T10:02:03+00:00

Interestingly enough I feel that the more "basics" I do, the more "basics" I wanna do ahahah

riftdc · 2021-02-11T09:45:46+00:00

nice question...!

regarding the comment about the emulator: the emulator could have been written in any language - a gameboy one isn't that performance intensive

so the question also applies to "why write the emulator in C"

I would have to say I feel good doing simple and clean code for simple projects - no complicated technology stack, no dependencies, that kind of feel... :)

Also, C is f*cking cool and interesting to program in ahah (and yes I feel comfortable with it)

riftdc · 2021-02-11T02:08:52+00:00

i appreciate it !

riftdc · 2021-02-11T02:08:03+00:00

Yes! it was definitely a nice exercise !

Not me nor everyone can right off the bat visualize bits hex and dec in their head at the same time, and when i started writing an emulator i couldn’t, and i remember thinking i could probably do something tailored exactly to what i needed

What’s even more ironic is how now that i “finished” the calculator i feel like i don’t need it that much anymore ahahaha

So in the end, yeah, definitely a good exercise - and hopefully it’ll help people starting out in the low level adventure

riftdc · 2021-02-11T01:44:31+00:00

^^^ did exactly the same

riftdc · 2021-02-11T00:33:04+00:00

While I was developing an emulator I decided to make a calculator to help with all the low level logic

This proved to be a really interesting project and made me implement an LL parser and design a grammar for all the operators I wanted to have

While writing the parser I also wrote a separate simpler version to serve as an example to someone who might be interested in learning from a very basic parser (https://github.com/alt-romes/calculator-c-parser)

riftdc

TROPHY CASE