Why did it take me almost a year to understand where there channel name came from? (coding -> цoding (ц is pronounced as /ts/) -> tsoding)

the talk about mozilla is actually accurate 😂😂

How about that!

Tsoding! I am actually glad you see you alive and kicking! I missed your streams on Twitch lately (can very well be due to my presence, lately, too), so I am happy to see you being active here. Keep it up and stay save, man. ;-)

Thank you so much for finishing the stream here, after it went off-line.

nice to see you again

Brilliant explanation! Thank you for making this. I enjoyed it very much 👍

[edit] never mind, I wrote this a few minutes before you mentioned it at 1:47:45 I've noticed that this system could really nicely be encapsulated in a C++ class: template class relative_ptr { public: // constructor(s) // operator= // operator* // operator-> // operator bool (for easy null checks) // operator++, --, +=, -= private: offset_type m_offset{}; }; if all of these are implemented correctly, they'd just be used like regular pointers. And due to the second (defaulted) template parameter, we could easily inject our preferred (signed) offset-type on declaration.

Can confirm, am a Rustaceon and almost had a heart attack when I heard null pointer.

Nice video as always. I learned a lot. Thank you.

"You nver have to call free, if you never called malloc" Thats how this guy managed to forgot memory leaks and truly live his life.

nice topic and explanation, thank u very much.. btw in my country, until recently we used pascal during high school until last year they introduced python, so ur not the only one using pascal

not important, but maybe someone is confused: 1 + 2 + 4 + 8 + 16 = 31, the number of elements in a (full) tree with L levels is 2^L - 1

for print_tree(), you can use %*s and pass level as an extra argument: fprintf(stream, "%*s-%s ", level, " ", node->text); or something like that

Well done🎉

36:48 I actually did end up saving the structure to the filesystem, loaded it back up, and everything works. I'm unable to to get a segmentation fault like he does in his video... I also noticed that I'm getting the same memory address for the root node both when writing to fruits.bin, and when loading everything back into memory. Here's the source code for anyone that wants it: #include #include #include #include #include #include #include #include "fruits.h" #define UNIMPLEMENTED \ do { \ fprintf(stderr, "%s:%d UNIMPLEMENTED ", __FILE__, __LINE__);\ exit(1); \ } while(0) #define UNUSED(x) (void)(x) typedef struct Node Node; struct Node { char text[32]; Node *left; Node *right; }; #define NODE_POOL_CAP 1024 typedef struct { size_t size; Node nodes[NODE_POOL_CAP]; } Node_Pool; static Node_Pool global_node = {0}; Node *node_pool_alloc(Node_Pool *np) { assert(np->size < NODE_POOL_CAP); Node *result = &np->nodes[np->size]; memset(result, 0, sizeof(Node)); np->size += 1; return result; } void node_set_text(Node *node, const char *text_cstr) { size_t n = strlen(text_cstr); if (n > sizeof(node->text) - 1) n = sizeof(node->text) - 1; memset(node->text, 0, sizeof(node->text)); memcpy(node->text, text_cstr, n); } Node *node_pool_alloc_with_text(Node_Pool *np, const char *text_cstr) { Node *result = node_pool_alloc(np); node_set_text(result, text_cstr); return result; } void print_tree(FILE *stream, Node *node, size_t level) { for (size_t i = 0; i < level; ++i) fputs(" ", stream); fputs((const char*)node->text, stream); fputc(' ', stream); if (node->left) print_tree(stream, node->left, level+1); if (node->right) print_tree(stream, node->right, level+1); } Node* random_tree(Node_Pool *np, size_t level) { if (level == 0) return NULL; Node *root = node_pool_alloc_with_text(np, fruits[rand()%fruits_count]); root->left = random_tree(np, level - 1); root->right = random_tree(np, level - 1); return root; } void save_node_pool_to_file(Node_Pool *np, const char *file_path) { FILE *out = fopen(file_path, "wb"); if (out == NULL) { fprintf(stderr, "ERROR: could not write to file %s: %s %s%d", file_path, strerror(errno), __FILE__, __LINE__); exit(1); } size_t n = fwrite(np->nodes, sizeof(Node), np->size, out); assert(n == np->size); if (ferror(out)) { fprintf(stderr, "ERROR: could not write to file %s: %s %s%d", file_path, strerror(errno), __FILE__, __LINE__); exit(1); } fclose(out); } void load_node_pool_from_file(Node_Pool *np, const char *file_path) { FILE *out = fopen(file_path, "rb"); if (out == NULL) { fprintf(stderr, "ERROR: could not read from file %s: %s %s%d", file_path, strerror(errno), __FILE__, __LINE__); exit(1); } fseek(out, 0, SEEK_END); long m = ftell(out); fseek(out, 0, SEEK_SET); assert(m % sizeof(Node) == 0); np->size = m / sizeof(Node); assert(np->size nodes, sizeof(Node), np->size, out); assert(n == np->size); if (ferror(out)) { fprintf(stderr, "ERROR: could not read from file %s: %s %s%d", file_path, strerror(errno), __FILE__, __LINE__); exit(1); } fclose(out); } #define FRUITS_BIN_PATH "fruits.bin" // loading tree into memory from fs int main(void) { printf("Loading from file... "); load_node_pool_from_file(&global_node, FRUITS_BIN_PATH); Node *root = &global_node.nodes[0]; printf("root: %p ", root); print_tree(stdout, root, 0); return 0; } // saving random tree to fs /* int main(void) */ /* { */ /* srand(time(0)); */ /* printf("Writing to file... "); */ /* Node* root = random_tree(&global_node, 3); */ /* printf("root: %p ", root); */ /* print_tree(stdout, root, 0); */ /* save_node_pool_to_file(&global_node, FRUITS_BIN_PATH); */ /* } */

I was hoping this video would explore some advanced pointer tricks, such as implementing doubly linked lists with just one "uintptr_t other" field for both the prev and next pointers, by using the xor identities: (x xor y) xor y = x, (x xor y) xor x = y. Like: struct Node { uintptr_t other; ... }; struct List {struct Node *head, *tailtip;}; struct Cursor {struct Node *prev, *curr, *next; }; Cursor first(struct List a) { if(a->head) return { 0, a->head, (struct Node *)(((uintptr_t)0)^(a->head->other))}; else return {0, 0, 0}; } such that for any struct Node *x, with previous node p and next node n (p==0 for the first node, n==0 for the last, or p == n if used for a circular list) x->other == (uintptr_t)p ^ (uintptr_t)n, so that by just keeping track of the current Node and its immediate neighbors in a cursor, you can move the cursor in both directions. (Yes, I *know* this most likely may cause problems with some GC library or debugger, and may not be worth the trouble in most situations.) I noticed the great confusion caused by mixing Node pointers, char pointers, and array element pointers. It would have been far easier to represent "small/relative" pointers as the direct nonnegative integer indexes into the node pool (ie relative to node_pool[0]), or to the signed integer offsets (ie if np[i] has a left child np[j], then np[i].left == j-i.) By making the offsets not byte-based (of course requiring all nodes being the same size) the bit width can be even smaller. I kind of had the impression that this was done to make C look a lot worse than it is...

At 1:44:34 you can see that the first `to_string` in line 10 uses c_style_strlen itself, so you could probably just write `s := to_string(text.data)`

12:33 the pointer in the linked list doesn't point to itself, but to the beginning of the struct. it is not zero, but negative.

I managed to accidentally find your old KZfaq channel while watching an old serenityos video

It reminds me doom's wad files) Since I've seen it, I always use these technics. Only few real pointers for memory allocation.

4:36 but, because of how structs works it would still allocate 16 bytes of memory insteaf of 12 bytes, because if you don't change it with a preprocessor thingy, it will always allocate like a multiple of sizeof(uintptr_t)

Ma fav Netflix series :)

Awesome pointer vid, just started learning C, and could understand like 25% of what you were doing haha

Remember, don't make memory safe code because you want your program to be secure and stable, make memory safe code so a rust dev doesn't have a heart attack.

It's interesting that they chose to do relative pointers in Jai. I personally avoid bit tricks with pointers and instead implement a flat index into arrays when I need a stable reference to data. Makes it far easier to serialize. Every time I have to implement a custom hash table for a project, I use indices for the chain data. It makes reallocations much faster and if I need to rebuild the table data it's a simple one pass operation anyhow.

Very nice explanation! However I don't get what is the benefit of this kind of pointers? Why are they better than "normal" relative pointers that counts from the beginning from the arena?

@TsodingDaily could you push the finished code to github to make it easier to follow?

Why not just strncpy at 17:50? This truncation problem already solved for so populat case.

Ah yes, C++ creator Bjarne Soursop

Does anyone know what font is being used in tsoding's emacs?

alternative for node_set_text: void node_set_text(Node* node, const char* text_cstr) { snprintf(node->text, sizeof(node->text), "%s", text_cstr); }

Turbo pascal was the best pascal. ;^}

Does anyone have a link for the discord?

Hey Tsoding! Have you ever used fp-ts? It allows a Haskell-esque coding style in TypeScript. Would love to know your opinion on it :) Have a great day!

A thing that I don’t get it is that when you desserialize it , how come the relative pointer isn’t filled with garbage or you get a piece of memory that is being used 🤔🤔🤔

Can someone explain to me why he implemented UNIMPLEMENTED as a do-while-loop?

3 times did not start, but then it worked

I'd like to see tsoding implement relative pointers in c++ using template class and operator overloading. It would be a very interesting video / live

27:01 "Why I switched to GitLab" comment section flashbacks

what is "Relative Pointers" concept?

I don't know why but every time dare to hit "play" on your video you consume +1h of my time.

Is?

31:07 fruits(zozi's humor) and it on line... nice try randomness

28:18

is there a use case where i must use malloc at all?

Relative pointers... So offsets?

do kernel development videos. do os development if possible

why make a unimplemented macro wtf just implement the damn code

I did not understand nothing