Comments by "" (@diadetediotedio6918) on "ThePrimeTime" channel.

  1. C# was the winner, clearly everybody was expecting this
    331
  2. Personally, I find that XML is like the Java of markup languages. Understand this as you wish.
    247
  3. It would not be Marx, more like an actual anarchist like Spooner.
    67
  4. For me the question boils down to a few simple concepts, 1. The object-oriented paradigm revolves around passing data between unified domains, not necessarily "classes" or "structs". That means you send information back and forth and try to make each specific domain responsible for interacting with that dataset within that scope of states. 2. The functional paradigm revolves around making code immediately obvious in a declarative way, even if that involves using data encapsulation methods and the like. The code must read fluently and it must be immediately obvious the result of an expression not by an individual stream of parts, but by the complete expression (and, of course, it must be decomposable). 3. The procedural paradigm revolves around ordering things in a specific, controlled way, not through statements or units, but through small, specific, determined logical steps that must modify or change the data as they are performed. The scope of a procedural code is always linear and it must be possible to read and understand linearly. To that extent, I can understand that all paradigms employ common concepts and can be summarized to common notions present individually in each of them, but which are not immediately reducible to these, as a complex system. Each of them has its place and I can understand why multi-paradigm languages won and purely functional or purely object-oriented languages became less and less popular.
    56
  5. the last part of your speech was surprisingly good
    54
  6. I like how almost everyone that call rust userbase "cultists" have a cultist way of talking and thinking about things.
    47
  7. Bro? From where did you draw that conclusions?
    34
  8. 9:56 I think this is a terrible take, to introduce a language that is not even production ready in the fricking most used kernel in the world. But what do I know.
    33
  9. No, I pretty much agree with him. He did not said "I prefer the pre-processor over Zig comptime", he said "I prefer pre-processor over Zig comptime IF we can't have generics", which is another thing. Comptime in zig feels more like a workaround to the fact that typesystems are a specific part of a language than anything concrete on itself.
    33
  10. 1. The stacktrace is not always necessary, literally, when you describe your errors as strong types modeled in your application. LITERALLY, they are not needed. And MANY times the stack traces are devoid of any meaning (for example, when you are dealing with an event loop). 2. This is not something exclusive for exceptions, you can pretty much have stack traces in errors as values as a default for a language (and you can do it in many languages with libs), so it do not make to say this is a point in defense of exceptions.
    33
  11. Rust still wins in the sense that the entire construct of the borrow checker is also to prevent many problems related to racing conditions and memory leaks, in Zig you just can't have many of these guarantees. But surely, Zig is indeed an interesting language, I just hope it's fanbase didn't turn into another C++-like toxic community
    32
  12. This is not strictly true lol, even in insecure mode Rust's borrow-checker still exists, and there are parts of the code where naturally insecure patterns will arise when we are dealing with layers closer to the hardware, it has nothing to do with how consistently secure a language is, but how generally secure it is.
    25
  13. 13:30 Why? I think it's quite obvious that certains workarounds would be provided by the community in any given language, this is a truth for serialization (as an example) in almost any language out there, C#, Kotlin, Java, Rust, C/C++, even Zig. Error handling is literally a very complicated task and having a community-driven lib for making things easier is 'ok', that's why we have things like macros in first place
    21
  14. solved decades ago?
    18
  15. 6:05 Now look at the C macros for complex codebases and see the "predictability"
    18
  16. I pretty much agree with the comptime take (which extends to the notion of types as values). * It makes it harder or almost impossible for the compiler to infer types * It is resolved after compilling, so you cannot expect reasonable hintings from the tooling * It is based on the strange conception that "type systems should not use a different syntax or be in a different world", while simultaneously making this distinction implicitly and explicitly many times because this is just how things work, it feels like a workaround to a problematic worldview more than a properly designed feature.
    17
  17.  @TheManinBlack9054  I think you are intentionally ignoring the problem here. The problem is never "adding synthetic data versus replacing all the data with synthetic data", but rather "at which scale with the mixture between synthetic and real data this will happen?" and also "if it does happen with purely synthetic data and do not happen with purely real data, does this means that the real data has something in it that the synthetic do not and this will cause the model degradation slowly over time in mixed data models?".
    17
  18.  @anonymousalexander6005  ["Moral of the story is that being self-taught is rarely being well-taught"] Well this is really some elitist bullshit.
    16
  19. Oh, regarding sync/async code variations, I think a look on the "generic keywords innitiative" post on Rust-lang blog would be a good read, it is a pretty interesting and I would say novel idea of bringing compiler-generated variations for sync/async code (and other types of discriminative keywords as well).
    15
  20.  @bobbycrosby9765  Is not "perfectly correct" because he also believed a proletariat dictatorship through the maximum state would be a necessary step of this "transition". So a real anarchist like Spooner would be more fit here, as I said.
    15
  21.  @akshay-kumar-007  "why log don't make sense there" Lol, in servers we log all fricking time, there is literally a bunch of specialized services that were made just for logging things in efficient manner and organizing logs.
    13
  22. In virtually any real-world scenario, unsafe code in Rust will be restricted to strictly extremely low-level matters like communicating with the hardware or doing some operations that would be impossible in everyday language. We can quote here on the issue of the benefits of the approach of creating security wrappers in Rust to interact with unsafe code Asahi Lina herself, who has already said quite clearly how much the borrow-checker (which by the way exists in unsafe scopes also in some level) and the compiler in general made her experience of developing the M1 GPU driver much less complicated and more pleasant than it would have been without these features on other languages. So, IMHO, if you're using this much unsafe code like this you've probably already started off on the wrong foot in what your code should be.
    13
  23. Bro, this is the easiest thing to say about anything, because ANYTHING can be used in such a way that the end result will become a spaghetti. abusus non tollit usum
    12
  24. It is fun bro
    12
  25. My sincere view, as someone who has been programming since 12, is that hard work pays off, but only if it's something you want to aim for. I'm not talking in terms of being something that you necessarily like, but of aiming for something bigger than yourself and working hard to achieve that goal, the other alternative is to work for something that you consider to be your calling. Every day I code 9-13 hours, sometimes more than that (it used to be more until my employers told me to stop for some reason), and when I'm not coding I'm reading about coding, I don't do that because I necessarily I'm looking for perfection (but of course, I'm always looking to be a better person than I was the day before), but because it's become something almost natural for me, because programming is something that interests me deeply, it's something that's part of of my life. I do not consider work as something external to me, or that there is some kind of mystical barrier between my personal and professional life, programming is part of me the same as craftsmanship is part of the craftsman, or carpentry part of the carpenter, this does not imply never doing anything different, or focusing only on that, but that doing things related to your craft is not a sacrifice but, many times, a pleasure, and I can definitely say that it is a pleasure for me. I can clearly feel the effects that all the years of work have had on me, for me it's clearly noticeable that after all that I'm better than before, not just as a programmer but in many ways as a human being, so I definitely think that, not only hard work, but mainly the feeling of being integrated with what one works on, is the essence of a complete life. I'm not saying that you should focus 15 hours a day on it, or that you need to, but that if you want to put more effort into what you do, improve yourself through hard work, that's something that comes with its downsides, but that also will most likely yield you the expected benefits. At such times, think about the nature of the craft, and that to each man men are "A medium-sized creature prone to great ambition."
    11
  26.  @luvincste  What is unintuitive about git?
    11
  27.  @Fillipser143  1. It has moderate compile times, I would not say "long", you can pretty much iterate in a few seconds depending on the extension of your modifications 2. It does not need JVM, it is the most common way to use it, but you can use it without in native-kotlin and even transpile kotlin to JS. And I don't see how exactly JVM would be a "drawback" on itself. 3. This I don't know, I use IDEA personally, but I have also used VSCode with it and it is a working experience, not great as in IDEA but still workable. But I understand this point in particular of yours.
    11
  28.  @astrosloth2  No, he is literally right. If xz was a proprietary software there would be no fricking way to discover that this vulnerability is real without much more work.
    10
  29. This could be solved by typescript being more strict about what it consideer a duck For me it is clear that a (number | string)[] is structurally different from a string[], and that a readonly T is different from just T, if they could just handle that taking in account the modifiers as part of the structure itself of the type it would solve this problem.
    10
  30. 3:12 I don't think that is a fair comparison at all. It is not like C++ has 38 years and Rust practically only 12-13, there's a fundamental difference in the workings and philosophy of all of these languages.
    10
  31.  @ccgarciab  [" A competent C team will probably attain memory safety by explicitly understanding ownership of data across call sites, and what constitutes safe usage of abstractions."] If this was true, then Rust would not be born in first place.
    10
  32.  @Zuftware  You can absolutely have both if your language is structured for it, exceptions were made to be <exceptional>, people made them the default in languages that have them because options were not provided for the other case.
    10
  33.  ThatGuyJamal  ?
    10
  34. 5:36 Also, I mean, a 50 years old language. This man really like to make bad points
    9
  35. Have you tried in ver 6? I'm on windows and the experience is not the best but far from terrible here
    8
  36.  @BrunodeSouzaLino  Are you being serious? Rust just pull the packages in build-time, it will not pull any packages in a "microcontroller environment", this would not make any sense. It is perfectly usable in embbed systems as stated in their own website.
    8
  37. 4:13 Yeah, and also unsafe. If you do not update your C codebase this seems more of lazy than responsible or a "good thing", software changes, operating system changes, things break even outside your control and keeping updated at whatever you are developing is always a good thing.
    8
  38. C++ had 30+ years to develop, so obviously there is a gap to close.
    7
  39. 16:00 C# can alloc on the stack, either by using structs or for arrays by using stackalloc type_str_unmanaged[length]
    7
  40. Open Source is just: you build some stuff -> people use it -> people can modify it trying to add more layers to this description usually ends bad.
    7
  41. 23:00 And if freezing your current thread to obtain the value makes your language not colored, then C# is also not, you have the .Result that will block until it gets the value
    7
  42. "many Rust developers" You started biased as this is not a "Rust thing", this is a "programming thing". Just as I saw many, many, many times C++ programmers saying C++ is the unique tool that should be used.
    7
  43. ​ @maaxxaam  I know he says this later (because someone in chat states it, not on his own to be fair), but this is a problematic instance on his previous take and other similar takes. He can't hold at the same time that zig was a better option (was, in the past, when they selected Rust as the next kernel language, I've seen him say this many times now, almost every single time he hear about Rust being selected for the kernel, since a time ago) and that zig is immature and thus it should not be used in the kernel (which is the production readyness thing), these are contradictory beliefs. He can say he thinks it is better suited for the job, which he also does, but not that "zig should've been selected instead of rust" (which he had said many times), my problem is more on the later. I also have problems with the "philosophical aligment" thing (as if Linus was not able to curate which languages should or should not be in the kernel for his own philosophical reasons) but I don't care enought to argue with it.
    7
  44.  @rebook0  > Says Rust is slow and all it has is marketing in a depreciative tone > Get's rationally responded by someone > "Typical toxic Rust developer. Nice."
    7
  45.  @LiveType  I don't think it's a "largely fixable problem", it depends on how you are thinking about approaching it. Because neural networks are fixed in size, they cannot grow or shrink like computer memory, they technically can't even modify their own weights permanently, so all the information storage and retrieval would be external to the model itself. And doing this was historically not at all very successful, at least with RL (even if technically "possible"). So maybe fixable, but I would not say lightly about it, it is extremely hard to fix.
    7
  46.  @BlackTakGolD  It is not stupid, if they achieved something revolutionary they would have good reasons to use it for themselves first.
    7
  47. Finally? This has been the defacto standart since software development started, why do you think we have such a big mess nowadays with safety?
    6
  48. ​ @jackoplumkin6412  Humans need """data""" (but I doubt we define data the same here), but they don't need a massive giant absurd enormous amount of data to do the tasks AI would require. And most of the data we have is noisy and extremely nonsignificant.
    6
  49. The word "need" is quite overused here, it is not "needed", it is the most used one
    6
  50. 9:19 Nah, borrow-checker prevents some data racing conditions too, the predictability of the memory state, and it is more concise, but it is a powerful feature to be reminded of something.
    6