That's one way to prepare for a potential EM blast from the sun

Clever

And you burn CPU cycles.

A silicone computer sounds like an interesting concept, but I suspect you meant silicon.

@@__christopher__ I like a stacked woman as much as the next man, but heaped implants just don't look as good... is that not what the video was about? 😆

Same here - it’s really hard to write non-trivial C++ code without understanding how memory works. For that reason alone, it’s a great language to learn.

@@ArjanCodes yes it really is a great language. Speaking on pandas in particular, since every method in pandas returns a dataframe or a series I do all my data manipulation and mutation in one scope by chaining methods instead of assigning to a variable for each transformation and creating a new heap allocated object.

@@abomayeeniatorudabo8203can I see some examples?

Yeah my favourite microcontroller has 128 __BYTES__ of SRAM... I don't do a lot of dynamic allocations. ;)

Thanks, will do!

You are most welcome!

Thank you!

You're welcome, Kilian!

Glad it was helpful, Michael!

Glad it was helpful!

Glad it was helpful!

Glad you liked it! 😊

Glad you liked it!

Yes! I had to enable the subtitles

Noted! :)

@@ArjanCodes ❤️

You’re welcome!

Thanks for sharing this! Glad I could help you :)

Thank you, glad you liked it!

Haha, thank you so much!

Thank you - glad you liked it.

Thank you so much 😀

Me too, i got scared. At 46

Thank you! Cheers!

Good to know! It’s been a while since I worked with C/C++.

Glad you enjoyed the video & thanks for the suggestion! 😊

global variables are not stored in the stack, but in a different region (data segment) which is never freed

​@@talicopowi'm afraid that is an implementation detail which varies by operating system, language, and data type. in some languages, especially interpreted ones, the only thing special about global variables is their scope, and the variables are placed on the heap, just like for any other routine. the difference being that the function in question is the main function, which does not get released until the program ends, and otherwise is managed just like any function. when the language uses compilation, and the operating system allows shared libraries, you end up with the code getting one section of immutable memory which can then be declared read only and shared between programs so you don't need to have multiple copies. in modern compilers, like llvm, it was realised that there is a subclass of global variables that also share this dynamic, and thus can be stored in another block treated the same way. this needs support in the operating system to be able to handle this immutable data block in shared libraries in this way. not every global variable is immutable, and in interpreted languages, the ability to determine this may be undecidable unless the language specifically supports declaring the variable to be this way. the same also applies to local variables. this becomes even worse if one of the main advantages of interpreted languages, the access to the evaluation function, is provided to the programmer, as at that point all memory access not declared to e immutable becomes dynamic, so the size of this block when you cannot declare a variable this way becomes zero. you then also have an additional problem that garbage collection has to be either on demand, or incremental. on demand halts all program execution until a fairly full sweep of memory has bean completed, which causes issues for real time programming, which requires the timings to be deterministic. the only solution to this is to do it incrementally, but the problem,with that is we have not been doing it for long, so the solutions are still at a fairly simplistic level in most implementations. also, while reflections and other methods of looking at internal detail of object oriented programs adds lots to the power of debugging in a language, it does so by breaking a lot of the guarantees needed to allocate the global variables to the immutable block. automated memory management is brilliant, but even when the programmer is granted the ability to tell the language to do things differently, it is very complicated. it requires systematic support at all levels from the bios up to the runtime execution of the specific program, or it does not work as well as the proponents hype it up to work. in the end, it it the programmer who knows best how the code is intended to be used, while the language should enable them to clarify that intent and enforce it with the help of lower level parts of the system.

variable handling in programs is complicated, and in functions it is even harder. this has to do with two key properties of a variable, scope and mutability. when you declare a global variable in the main function, you know the scope is going to be global. if it is a value like pi, you also know it is not supposed to change, so in a compiled language you can allocate it to an immutable data block with global scope, and hope that the library management code supports and enforces this being a single copy of read only data. when you then pass pi to your function, it can either be as a global variable, or as a parameter to thar function. if the language uses call by value, you then know that it will have a scope of the function lifetime, and it will not be returned to the same variable. as it is a copy of the data, any changes will only last the lifetime of the function, so you can store it on the stack. even better if nothing in the function writes to it, you can also decide at analysis time it is immutable. the same also applies with any other variable you explicitly declare to be local or immutable, so it can also go on the stack.anything that has to survive the termination of the function has to be treated by the function as global, but can be explicitly local to any calling function, or can be local to the library. depending on support within the language and the operating system, knowledge that something is global and immutable can be used to minimise total memory usage, and language support should be provided to enable the programmer to explicitly declare both scope and mutability, but most languages don't support that functionality. to the extent that this is not supported, the language has to guess, but currently the algorithms which exist to support such guessing are fairly primitive. also the way the guessing is done tends to be both language and implementation specific. the guessing gets even harder if the language is interpreted, and even more so if you have complex objects with variable length data types in them. in some languages like the original implementation of lisp, even the program code is not guaranteed to remain the same for the duration of the program, as a function is just another piece of data which can be changed by another function. anything which is correctly guessed to be read only and of fixed scope can go on the stack, which includes some global variables. literally everything else must go on the heap, at which point the problems of garbage collecting the heap get further complicated by the same problems. you can only remove something from the heap if you know it is not needed anymore. for simple but advanced data structures you can use reference counting to determine that it has no users, and rapidly collect that part of the heap back into free space. if you know that in the first part of the program you are going to load in some data, use it to build another data structure used by the second part, and is then no longer needed by the rest of the program, you could free off that part of the heap at that point, but only if you can tell the language it is safe to do so. otherwise it is back to guessing, and if you cannot be sure you have to keep it around. at the operating system level it is even worse, because it has to deal with every heap and every stack for every running program, and handle virtual memory for when you run out. memory management is not simple, and won^t be for a long time, and comes with large costs whatever solution you choose.

Glad you liked the video :)

Thanks!

Haha, exactly!

Good point!

Haha, right on! 💪

That video will be made available shortly on my OnlyFans.