Caseymuratori

=== papers ===
https://caseymuratori.com/blog_0030
http://the-witness.net/news/
=== cpp ===
https://caseymuratori.com/blog_0015 from https://news.ycombinator.com/item?id=24008557 We all know how to program in C++, don’t we? I mean, we’ve all read a selection of wonderful books by the gaggle of bearded fellows who defined the language in the first place, so we’ve all learned the best ways to write C++ code that solves real-world problems.
First, you look at the real world problem — say, a payroll system — and you see that it has some plural nouns in it: “employees”, “managers”, etc. So the first thing you need to do is make classes for each of these nouns. There should be an employee class and a manager class, at least.
If you’re not used to programming like this, you may think I’m exaggerating, but you’ll just have to trust me, it’s true. I spend exactly zero time thinking about “objects” or what goes where. The fallacy of “object-oriented programming” is exactly that: that code is at all “object-oriented”. It isn’t. Code is procedurally oriented, and the “objects” are simply constructs that arise that allow procedures to be reused. So if you just let that happen instead of trying to force everything to work backwards, programming becomes immensely more pleasant.
https://caseymuratori.com/blog_0017
Now, I would like to point out that, although it sounds like it, this is actually not me dissing object-oriented programming again (I’ll do that a bit later). This diss is more specifically targeted at C++, because there are plenty of object-oriented languages out there where it would not be necessary to implement the enum yourself — it could be created from the hierarchy itself automatically in a stable and useful way that is not janky like C++’s feeble RTTI. And as C++ continues to bloat to Stay-Puft Marshmallow Man proportions with every passing spec, it will probably be the case eventually (if it is not already) that you can use a bunch of new language features to perhaps eventually get to the point where it is not so onerous to use the class-based method even in C++. But honestly, even at that point, it would still be a lot more typing than just the simple enum list.
=== table oriented ===
https://caseymuratori.com/blog_0019
=== virtual tables ===
https://www.youtube.com/watch?v=zjkuXtiG1og&list=RDGKYCA3UsmrU&index=10 "But, suppose you were to introduce a virtual functio. Inside this (foo) struct, the compiler would silently introduce a pointer to what's called a VTable, which is a dispatch table - that is how it actually implements virtual functions. Now, you have no way of initializing that virtual table yourself, because you don't even know where.... you don't know anything about that - that's a compiler detail. And so one of the things "new" also does, is it initializes any hidden information that you did not put there, but the compiler did. And so, if you start using compiler features, C++ features, that the compiler needs to augment the structure of the class with, and which have important inititialization that has to happen, you must call "new", even if you don't care about the compiler calling your constructor. Because the compiler, essentially, has a constructor that has to get called and it is initialization of that VTable." See Mike Acton on virtual tables. 
compares malloc with new and del from c++ and disses nodejs and php
=== links ===
https://www.intezer.com/blog/research/a-storm-is-brewing-ipstorm-now-has-linux-malware/ from https://github.com/timb-machine/linux-malware golang attack over Ipfs network. 
Nouns and verbs oop
https://www.youtube.com/watch?v=1HAXgM3mjSo go, rust
Category:Oop