Comments by "MrAbrazildo" (@MrAbrazildo) on "No Boilerplate" channel.

  1. 2:37, I code that in C++, for runtime. It gives me the container name, its size and the index used, but don't give the command neither its line.
    3
  2. 4:34, in C++, it's possible to overload most operators without using metaprogramming. And it can be restricted to a class or not. Tied to a class, it's not bad form, because the class meaning should be self-explanatory. 9:01, how many lines of code this mean? In C++, 5s for ~10k lines, with optimization flags on.
    2
  3. 3:10, this is not true. I would make a banana, gorila and jungle as 3 different/independent classes. Banana would reuse its fruit base class, as well as gorila with its animal base. 3:20, I don't have been facing this case. I guess I would just make Developer inherit Designer, and call the last 1 FullStackWorker. 10:15, I don't know, it seems that this computes only that combination flow, not all paths. Does it cover if mario gets the feather right away, for instance? Anyway, I made a C++ version that covers all combinations. After dozens lines of declarations, the user can code just 1 line. For your example: mario << Mushroom << Flower << Feather; assert (mario == CapeMario);
    2
  4.  @NoBoilerplate  I don't know Lisp macros. C++ has 3 special ways to deal with compile time: - constexpr: it can make all calculations, but the result must be const. It can be attributed to a const, though. - template: a model of how a f() will work. It will make 1 for each type, according to calls. - macro: it pretends you wrote the code in a specific way. I heard the difference is that Rust uses "hygienic" macros. Probably avoiding the classical error: #define add(a, b) a + b int x = 3*add (1, 2); //Resulting in 3*1 + 2 = 5, not the expected 3*(1 + 2 = 3) = 3*3 = 9. There's also a 4th hidden way, dealing with variables at compile time: making template f()s generate other template f()s, with different constants, according to "variable" changes. PS: I forgot to say that that C++ time has exceptions flags off. PS2: your link shows this same video.
    1
  5. 0:37, to GitHub, doesn't matter your license: it'll always be free. 2:28, interesting, in a sense of freeing things from memory. The problem is that, when you finish a small task, it'll eventually need to be broke, to attach a glue to it, in order to serve to a bigger "ecosystem", throughout the project development. So 1 will keep going back to that task, to improve it. Another strategy is to get the project in working state, even if in kind of a bad design. This gives information of how things should interact. Some things are only known in practice. And if things are decently isolated, like it's possible to do in C++ (private setters, for instance), details can easily be improved without fearing the rest of the project influence. Nowadays, mankind is experienced enough to know certain strategies, to advance fast through a project, like automated tests, keep same patterns for everybody, decent encapsulation (as I mentioned, private setters), and so on. 3:00, autism is a severe condition, making the person almost incommunicable. You hadn't it, you were just introspective. 3:36, this is the proof: these are extrovert features. Just train those for a little while, giving them their deserved value, and anyone can acquire them. Autism would never be solved this way. 7:08, there's a mindset switching issue. It's unpleasant to do that, and thus may be hard when the time for the most unpleasant task arrives. So, if it take longer than should for 1 person, I agree. On the other hand, if it's not the case, it's better to start by the easy things, for motivation. When coding, I prefer this last method. For life chores, I think the other is more recommendable. 10:05, I prefer blocks made of 2h of tactical work, 1h of strategic work. But I guess you are not being entirely honest about timed work. There are small distractions, and if you stop the timer for those, being brutally honest, it'll yield almost double of that! By my experience, 2h -> 3:30, 4h -> 7:15-20. 11:00, maybe the headaches are caused by trying to suppress those distractions completely. I don't do that. Instead, I just stop the timer, think/do whatever triviality I want at that point (even if just a brief thought), and then back to work. Before reactivating the timer, I get a little focus 1st. I never had a headache in life!
    1
  6. 1:49, even when I used to code in C it didn't crash all the time. But C++ is the right solution. There are so many possible abstractions tools to develop using it, that you can fight back the dangerous from C. The major issue is still the pletora of UBs. 4:18, C++ allows to std::move a variable, but you have to do it explicitly (by copy is default). And if you use the moved 1, the app becomes unstable. Fortunately, there are external tools that catch this kind of bug. 8:00, D has an optional GC, while C/C++ rely on external tools to solve this. The memory issue is kind of solved nowadays. 9:50, this is as old as C, as reference is implemented as a pointer. It should not even be in your list. 10:00, does C has now templates? It really needs it. But I guess you are thinking about C++. Templates are safer than macros, but also less powerful. What Rust innovated was hygienic macros: a bit less powerful than C/C++, but more safe. 10:09, C++ has template metaprogramming which is pretty nice. The compiler follows you, saying "Hey, you mistook here". At least in C++ is safe. C still depends on macros. 11:04, no classes == no clothes.
    1
  7. I made a Rust and Haskell syntax for C++ (I didn't know Rust had this powerful option too) . I even improved performance for C++, by changing the algorithm. Take a look on my comments, on the comments section of this video: https://www.youtube.com/watch?v=wGCWlI4A5z4
    1