Notices by LR (lritter@mastodon.gamedev.place), page 3

there never was a beginning of space and time,

therefore, it will never end, either.

states of matter and mind come and go.

scientifically terrifying

because it is unknowable:

the origin of everything.

i get it now, mysticism. the void is not empty - merely unyielding. you keep the void in mind. much can be revealed, but some will never. so you pick the eternally unrevealable, make it your symbol. your contemplative focus point. something to struggle against, as not to struggle would be to resign to ignorance: resting in what little light you found. a mysticist must reveal. only through revealing they will struggle against the void, first to all that is, second to none.

is the void in the past? is it in the future? yes. i came from it and i shall return to it, having seen all i can see but none the wiser.

can revealing be done efficiently? all it takes is to meet the uncomfortable. this challenge can never be efficient, hence the struggle.

for images of the void, close your eyes or imagine a fully connected graph as its number of vertices increases. think of the void star. the rim of a mandelbrot. there are eight billion images of the void.

every time i watch robin hood i'm feeling like this is the ground zero of furrydom

ironic that we live in a time where everybody owns a computer with a mandatory button that spawns a supposed "magical genie", except for computer witches & wizards who specifically do *not* have such a button anywhere, nor do they wish to have one

netanyahu's fight against hamas is, at the very least, an incompetent blunder, and can only be named as such.

@dosnostalgic doesn't look like anything to me

hating myself right now for having written so much code.

a lot of this was written with the assumption that "it's only bootstrapping, no need to be dilligent, all this will be replaced".

well guess what, dipshit. it's 10 years later and this is still the state of the art implementation.

in soviet russia, corner cuts you.

#devlog #scopes

sigh. i just have too much on my plate. i'm now just porting the Scope implementation almost as it is now and do this another day.

funny, "porting" feels more correct here than "refactoring".

#devlog #scopes

scope.cpp is ported, now we're moving on to a bunch of smaller types, until we're eventually arriving at value.cpp, which does a lot.

it's easy to tell how far i'm along because the generated makefile compiles sources in lexicographic order. 11 sources left. :)

#devlog #scopes

today i'm beginning translating Scopes' internal OOP based system to datalog/database/ECS layout, that is, all pointers become enum-typed indices and object attributes are mapped in arrays.

to begin, i'm writing a small DSL in Scopes to describe the datamodel, and then auto-translate it to C++

this is the type tree from which classes and enums will be generated:
https://paste.sr.ht/~duangle/31522a60cf978fe7483cfdd32f1fca7293daaffc

next, we need index attributes (aka struct fields), and auxiliary tables (options, maps)

#devlog #scopes

phew. five hours later, i've translated *all types* used by Scopes into this format, from which C++ definitions will be derived.

what i like particularly here is that all sub-enums like ICmpKind or TypeKind, and even all error codes, are flattened into the main ValueKind one, but can still be their own enumerator types.

many branch-dependent special cases are now unified this way.

https://hg.sr.ht/~duangle/scopes/browse/src/Value.sx?rev=based

#devlog #scopes

the parser for Value.sx now fully parses the definition file in 455 lines.

https://hg.sr.ht/~duangle/scopes/raw/lib/scopes/compiler/pilot/gencc.sc?rev=based

now we need to generate some actual C++ code.

#devlog #scopes

we have generated some code. instead of generating plain C++ expressions i employ the same technique i did with the scopes² prototype: generate macro expressions and let the preprocessor translate.

left is an impression of what the output looks like (header file). right is the file used to translate it to C definitions. most of it is stubs so the code compiles at all.

#devlog #scopes

in full refactoring flow now, as i replace explicit classes with generated types, turn methods into functions, figure out small extensions to the type generator, etc.

as a result, codebase's getting smaller, which is always a good sign.

#devlog #scopes

lots of refactoring today. codebase is completely shot. changes everywhere. many deletions. into the rabbit hole i go.

#devlog #scopes

voting this the least helpful error message in C++ (it's a bit verbose because i use heavily templated types, and C++ doesn't know when to quit describing nesting structures).

you get this when you use a type for STL hashmaps that's not supported by std::hash. it doesn't actually tell you where you made that mistake. it does in fact tell you nothing useful aside from the type used. you just have to know by experience.

#devlog #scopes

expander.cpp is the first big module to be fully updated, now i'm updating gen_llvm.cpp. it's the mother of all refactorings.

#devlog #scopes

gen_llvm.cpp is updated, next is globals.cpp. this one implements the C API wrapper around the C++ parts of the compiler and also exports all API symbols to the client context, which looks like below.

these 600+ lines of definitions are all manually maintained, but could be autogenerated from scopes.h alone, which i'll implement now.

#devlog #scopes

de-optimizing Scope objects to speed the refactor along (I have a much better optimization to apply later), and updating related API functions.

#devlog #scopes