Comments by "George Albany" (@Spartan322) on "Low Level"
channel.
-
145
-
42
-
28
-
17
-
15
-
13
-
11
-
9
-
9
-
9
-
@borkbunns
"Cherry picking cheaters and placing them into their own lobbies would only make them realize that they're playing against other players using the same cheats as them, causing them to wise up and quickly change their methods"
First off most cheaters don't care who they play against, else you'd quickly see cheating peak and then drop statistically as they get disinterested in competing with a saturation of cheaters to an equilibrium, (we do not see this take place) most hackers don't care if they play hvh or not, many in fact intentionally initiate it. Majority of them would already not care.
Also the principal is they can't enter non-cheating servers, once marked a cheater, they stay a cheater, so changing their methods is worthless. The problem with banning is it encourages cheaters to make new accounts because they have no choice, majority of them wouldn't do this on the simple fact that they'd have to actively change their behavior instead of placating to some form of pleasure, of which such people are mostly not gonna do. (most people are not self-controlled and once they partake in a pleasure, until you punish them outright they won't stop, this is basic human nature)
"Even Riot has spoke about this topic but with regards to toxicity, which is probably the bigger issue with League itself honestly."
Few issues with this, first off this is a complete incomparable, toxic behavior is highly subjective, and where the lines reside inherently is indeterminable, and once you start drawing lines, people will just start trying to redefine it and tow the line to get away with as much as possible, and it usually isn't considered a good idea to outright ban everyone who partakes in any even slightly toxic behavior. As well I know Riot has not performed much of any real experiments on toxicity either, so what they say on the topic is theoretical at best. Also wouldn't it be inherently desirable to reform (or encourage reform of) player behavior to lessen toxicity? Doesn't that kinda prove the whole point in regards to toxicity? The same doesn't hold true for cheating specifically because its a black-and-white objective metric that we merely may have a hard time externally tracking in all cases, but we objectively can observe clear cases of it, toxicity does not have an objective case and a computer would never be capable to know this without sentience. In that regard toxicity would be lessened purely by incentives and encouraging the players and so the game would be better even when it doesn't solve the issue.
8
-
7
-
6
-
@krunkle5136 I've begin to feel more like the Rust community is a cult and less a group of developers interested in anything better then C, they always claim security but all hell breaks lose if you criticize their precious religion. I wish I didn't resent them so much but when every time you make a criticism and they respond with being mean about it it only further alienates me to Rust and pisses me off. I already hate the language, but now I'm growing to hate even the people associated with the language if they can't even take the most basic of criticism.
I have been constantly and intentionally personally attacked numerous times for despising both the syntax and build system's reliance on Cargo, they couldn't refute what I said every time I brought it up, and then would resort to just telling me its better and "solves a problem" but never actually gave me refutations of what I would say. I've said things like this numerous times about hating the syntax (explaining some of my issues with the syntax, which resulted in me needing to explain that I do in fact know that a language having a new syntax would need to be redesigned, no longer being the same language, don't ask me why someone would think I wouldn't know this) and build system dependencies issues and how it violates FOSS and Unix philosophies openly for dumb reasons, and every time the result would be me being told "You don't understand why the language was designed that way" despite having at least written my own parsers and having read the Rust dev's justifications and finding them poor excuses and "it solves annoying problem of 20 different build systems in C++" despite never even referring specifically to the build system being an issue, just the dependency and lack modularity issue thanks to things like cargo being required to use the build system. I've used npm, pip, and nuget enough to know relying on a package manager as a part of the build process, especially one you can't switch out for your own needs, is both stupid and frustrating, and likely to crash your builds. These basic points piss them off.
5
-
5
-
5
-
Two things to point out:
1. Nobody can define trademark law for themselves, that's defined by local laws you can't redefine it and its not legally binding, (especially if nobody signs away their "rights" for it) so I really don't get why this policy even needs to exist. It doesn't hold up in court. The only thing is serves to do is explain what would be friendly to the project.
2. The Rust Foundation hid a bunch of strange biased leftist talking points in the trademark policy that suggest the Rust Foundation has gone woke, which explains why they responded back with the whole "we're being attacked and victimized" crap in their second reply, for example they mentioned that changing the logo can apply to pride month, LGBT support, Black Lives Matter, and included nothing about supporting non-woke or anti-woke movements, which is strange, but what really damned them in my eyes was when they said you cannot host an event on Rust's trademark without banning guns from the event and forcing health mandates on the participants. They don't have that right, you can't freaking say that, and now they're trying to restrict the freedom of individuals specifically targeting Americans in a discriminatory manner. That is encouraging illegal behavior, if they have an event in say Texas or Tennessee, it is illegal to restrict the right of firearms for a public event, same with health mandates, especially if you don't own the building, and you can and will be sued for that, and you will lose. That's forcing people to break the law in order to comply with this false principal of trademark law.
4
-
4
-
4
-
4
-
3
-
3
-
Inheritance and runtime polymorphism can be separately useful in all sorts of places, but together they can cause issues if you're not careful and deliberate with their use, even then the applied classes need to be "atomic" as in simplistic and not divisible for your use case. Unfortunately a lot of C++ developers have been around Java and C# too much which destroys the multi-paradigm nature of C++ in their mind and ruins them as developers. I don't think I'd ever consider it as harmful as goto, since goto has killed people and disrupts standard flow control and its not hard to see why it would kill as a result, (and not to mention 99% of those cases is because multi-loop breakouts are otherwise impossible, so its an oversight that has an easy syntax address) whereas polymorphic inheritance is not disruptive to the flow by its nature, if you're using it to do that, its garunteed your first mistake was not polymorphic inheritance, and most of the cost is likely to be in performance, not production quality, though if you want to consider an non-scalable development as "production quality" then sure, but I wouldn't consider it that, it would then only produce developmental hell at the worst.
3
-
3
-
3
-
2
-
2
-
2
-
2
-
2
-
2
-
2
-
2
-
2
-
2
-
1
-
@T0m1s That's not an argument for your position and its not logically sound.
Second to that, what someone claims, no matter how significant to the topic they are, does not make their claims true. If words are not gonna mean anything then there is no point communicating in the first place, its a waste of consideration to hold to this position and then to continue an argument in a language both of us can understand. A design is a design, a pattern is a pattern, when you have a pattern of design, that's still a design pattern, I don't care what fancy bullcrap you try to dress it up to placate your worthless pride and ego of superiority to someone else simply because you disagree, the concept is the same. There is not a single language that does not have patterns of design, ergo design patterns. If someone is gonna insist something shouldn't be called by its English words, I'm gonna tell their ignorant dumbass to shutup and stop trying to control language and manipulate words. You don't own the language nor the words in it. Nobody does.
If you want to argue over language paradigms, stop hiding behind pedantic foolishness to glorify yourself and put other people down, that just makes you a moron and there is no reason to consider your position nor anyone who shares your position.
And no I don't care how prolific someone is, that doesn't make them great, they are still required to maintain an argument and if they can't that just means everyone else is also a moron brainwashed by their worship of another worthless god.
If you can't sustain a position independently and effectively, to rationalize and speak clear points in argument and counter-argument, the problem is you and your argument, not me.
1
-
@u9vata I would distinguish between production quality and developmental quality, scalability and long-term ease of development (which is generally distinct though related to maintenance) are completely worthless to a customer generally, and they're not always worthwhile even for you to do, this is another reason it depends on the tool, sometimes a quick and dirty solution is all you're allowed and that's another advantage, though many folks look down on it, I wouldn't discount that fact and I've definitely seen cases of virtual inheritance being adequate for short term development, in some cases speed and memory usage aren't a problem, its pure development time and functionality, so long as the user can reasonably use the application comfortably and it actually works, you're good. Course an issue may arise if a customer also tries to ask for extra elements that aren't exposed in the middle of development, but every paradigm carries that problem to some extent and you are trading dev time for scalability there. Everything is about tradeoffs too.
1
-
@u9vata Threading is inherently dangerous regardless of what you use, because there is no determinism with threading, you can never expect any order or organization to what you use so it does not matter what paradigm you use, you cannot guarantee an outcome's correctness (in terms of flow or sequence) without extraneous and tedious work, and it is near impossible to track every hole you open unless you figure out how to convert literally every operation into an atomic operation. (which is generally not possible even in the simplest of cases, and even then its not performant and could even cost you more then any other paradigm you could've used) And that's before we consider race conditions, or if you try to prevent race conditions, you might cause a deadlock instead and now your program might be wasting time doing nothing or wasting a thread it can't access, or even just wasting resources keeping a thread alive for no reason. If anything threading is almost (and I literally mean) as deadly as goto, its only because its danger is so well seen that its unlikely that anyone is to step upon that lethality unlike goto, though even then I wouldn't call that rule, all it takes is one person to slip up once with threading, something even easier to do then with goto especially since debugging them is 10 times harder then goto ever was.
It really isn't fair to bring threading into this argument when threading itself is the issue there, more then anything else you could reference, it can make things slower if used wrong which is easy to do, its not easy to intuit even in a simple case, it can break in any number of ways that allow a programatic valid state that should be invalid, it can deadlock the application and break expected sequence of the application in a hard to debug manner, which it is already designed explicitly to do.
1
-
@u9vata I never said it was "shit", I said its inherently dangerous, it doesn't matter what language you try to do it in, everything I've said about it is inherent to every language, it doesn't matter how insulated the language tries to be.
Threading is literally more dangerous then anything else you could've pulled up, the reason its useful is specifically because that danger is also extremely flexible and unique to solving problems. (and even then use it wrong and it'll be the worst performing thing you ever write, even perhaps freezing the program, there is no insulation against this without additional tools which aren't themselves threading in the first place)
Everything you stated is foremost based on a strawman, then a red herring, and then furthermore a false conclusion. And OOP and runtime polymorphism is not inherently problematic for handling this, there are plenty of both applications and libraries that do it in an OOP way which have high amounts safety for handling this anyway, even in C++. We weren't even talking about specifically OOP anyway since runtime polymorphism isn't actually even required for it and inheritance does not need to be specifically involved in the polymorphism anyway, you can still get objects without these elements. Not to mention that C++ runtime polymorphism is not the end all be all of runtime polymorphism, the reason its like that is for historical reasons, it was at one time faster and safer to do it that way, but that is no longer the case, systems have made the C++ vtables outdated.
Also that aside you can make virtual method calls about as fast as any single parameter function call anyway, if you know how to actually write C++.
1
-
@u9vata
"No this is not true. You can totally auto-parallelize some functional languages and the question is only where to do it when there are no blocking waiting."
The principals of threading still apply and the anti-side effect nature of completely pure FP is inherently less performant and going to give you scalability problems.
"Otherwise you can apply the fact that function application chains are associative and then you pull out college 101 about how every associative function can be auto-parallelized and write a compiler for it."
That's not a scalable technique for development. And again that doesn't fix the issues with threading, that just prevents you from full utilizing its capacity. Auto-parallelization is not a fix, its an insulation tactic, you might as well just compare it to concurrency, they share very similar application domains.
"Then for regular function call chains you can also do pipelined parallelism... All automatic - all multi-threaded and if you want that even multi-node."
I'm still not sure how that solves the problem with threading I described, you're just sequencing it then, which is just concurrency anyway.
"This is not needed to be strictly functional - we had courses on some homegrown language a local company made which was declarative and auto-parallelized."
Now demonstrate it in a real scalable project of multiple developers and perhaps I'll consider it. A lot of declarative languages are almost functionally always DSLs, they rarely suit more then a specific function. I don't care about DSLs. (which half the time even functional languages start to act like as well)
"Basically with impossible to write race conditions or deadlocks (livelocks were possible for them though - but not in the above example)."
Except race conditions and deadlocks come with high performance code alongside threading, FP is often the least performant when it comes to how it deals with values, or it'll come with a limitation on the use of variables in specific contexts, so you're domain of functionality and problem solving is limited in one way or another, which makes it only suitable to specific use cases and a lot less general of a general programming language then non-FP languages, the concepts of FP are useful, but most actual FPLs a lot less so. Singular paradigm languages just tend to suck. Unfortunately everyone keeps trying to shove them into a general purpose mindset like a moron and then they wonder why these languages are mass adopted. You're shooting yourself in the foot just to be disappointed then.
"This is only not done, because you can totally press out more performance doing this manually."
Defeating part of the point throwing instructions to your compiler then.
"So this is not at all widespread."
Also meaning its not actually general purpose either. Which limits its usefulness anyway
"I also prefer doing it manually,"
I really don't care about preferences and opinions here.
"just saying it is bad argument to say asyncronous coding has to be always the worst."
You need to stop confusing threading and asynchronous, they are not the same thing. When I'm talking about threading, I'm not referring to concurrency. A threaded model means segregated processed of operation on different logical cores of the CPU, (or technically also GPU but unless you're performing GPU computing with shaders, where cryptomining being the only massive scale example of that, you're not usually doing this) concurrency and asynchronous refers to making non-sequential operation calls, but they're functionally never threaded.
"Yes I agree its harder than regular - and if some part is automated you still somewhere pay some price like learning weird languages, not utilizing everything or such stuff - at least currently. But my point was that it really counts which environments actively go against parallelism and which not..."
And you literally prove my point with this, even despite seeming to confuse concurrency and multi-threading. If I call something asynchronous, I am not referring to threading, its exceptionally rare to ever use both and asynchronous calls are completely memory safe and can't deadlock, asynchronous refers to non-sequential performance of operations, the latter refers to parallel operations. You can't use them interchangeably.
"Honestly... many cases a non-blocking I/O or green threads or threads confined to the same logical processor thus not needing any locking.... they in most cases would be more than enough. Why? Because for at least half (but likely much more) of all cases where it is used they use it not to speed up things, but to run while something happens in the background or while waiting for I/O."
That still functionally concurrency, which does not suit this case in most instances. Or it might be event driven concurrency but then you lose the capacity to control over the operations anyway. And not to mention it needs to be integrally implemented for each OS which is a pain to do and ensure is happening correctly. (and then it not technically guaranteed and it won't exactly be performant and can still actually block)
You could just as much just produce one-way readonly behavior and thus its still thread safe, race conditions are only an issue in a two-way write environment, if one side is write-only (it can be read-write but usually you don't need to) and the other side is read-only to the data, you won't ever have a race condition anyway. This example is a perfect case for that. (functionally the thread is producing a readonly buffer, if you want to read and write, you'd need to use two separate buffers which are both one way)
"It is an exact example: inheritance based typical OO polymorphism can easily fail where other approaches would not."
Depends on the problem. There are definitely cases for it.
"But again: my point was not on this example. It came up because you bring up that goto can kill - so do inheritance easily."
Except inheritance isn't the issue here, inheritance by itself would still provide a clear chain of visible calls, especially with how its implemented in C++, all inheritance does is allow more structured code recycling. That's no more a problem then the existence of functions. (course when you try to solve problems with inheritance that don't suit inheritance, now you're just being a retard, but there are certainly cases for it to be useful) What you're complaining about is how C++ runtime polymorphism with vtables interfaces with inheritance, which sure can be stupid if you use it to solve some problems, but it still can be a solution to some problems.
Goto inherently violates the structured flow of your code, inheritance does not, even runtime polymorphic calls don't inherently, though its not hard to make them do so, but the issue here is the polymorphism, not the inheritance.
"Also I would argue a this pointer slipping out of the baseclass constructor is more of an issue related to inheritance than the bug you imagine with GOTO."
What do you mean by the "this" pointer slipping out of the base class constructor? Constructors are sequential operations that call back to base constructors in C++, the this pointer in C++ is always type-safe and highly regulated.
1
-
@u9vata
"Just tell me: What is wrong with GOTO that makes it worse?"
Program flow manipulation is a lot more dangerous it will forcibly skip instructions, and forcibly skipping instructions causes way more destruction especially for intuitive operation of the program. This is also why threading is dangerous.
"Do not say generalizations, but specific examples. How would it kill?"
I've tried to pull up cases where it did kill people, I believed it was the Therac-25 but I can't find any documentation that speaks about the specific reason the bug was caused. (though it is quite likely it was a goto, I can't say for certain if it was) I remember reading up on at least a case where it was directly implicated in killing people somewhere but I can't find the articles for this case.
"My argument is that GOTO can kill not because goto works bad somehow - but because using GOTO complicates and spaghettifies the code - so do OO currently."
Its the disruption of the program's flow, not simply because it "spaghettifies" the code, systematic complexity is a natural part of programming, if you don't expect it then you're a fool. OOP is not inherently any more susceptible then any other assistant features in programming. (or functionally any abstraction in programming ever, they made the same arguments with the invention of functions, and no I'm not joking, that seriously did happen) And OOP doesn't even disrupt the flow of the program so its not even remotely the worst case for it. Event signaling, multi-threading, concurrency, flow interpretation, unregulated flow jumping, these are all more disruptive to a program then anything you can do with OOP. You also attribute OOP to runtime polymorphism but that existed before OOP, and you can make an OO language without it. Inheritance is just about code recycling, it has nothing to do with this. (not to mention you can do runtime polymorphism in what you consider as "sane" ways too, and with performance to boot) This is why goto is worse, it is a form of unregulated flow jumping which can skip required sequential code, to get the same behavior with anything in OOP requires you writing the sequence that way already, with goto you are skipping the sequence responsible for that and it is not perfectly clear when you are doing that.
"Maybe you can present some other way GOTO is harmful because it is not me, but you who wanted to separate "what is good for development and for the product" - while I keep to my point that bugs more easily arise if things are bad for development - and especially with GOTO, those bugs are because you cannot follow what is happening."
Nobody can understand the whole of a program, (unless it is so simple that it accomplishes very little, which works with some cases but not all) it simply becomes too big to do so, and if you have multiple people working on it, that's only even more true, the only way to make it easy to read is to be sensible, follow standards, produce block box operation mentality, (as in make it easy to compartmentalize operations without knowledge) and document program details. This applies to every language and non-OOP is no more suited to this then OOP, you are still required to do the same. If you think non-OOP changes this you don't have much experience least of all in multi-personnel development, and you've probably never worked on a significantly complicated piece of software.
1
-
1
-
1
-
1
-
1
-
1
-
1
-
@T0m1s
"You comment can be viewed as not 100% honest, but you're probably just OOP-brainwashed."
Well first off that's an ad hominem, but also that's just a stupid statement in general, like it was literally false that methods are inherently virtual in C++, that vtables will be made with virtual classes at all times, and that virtual function calls are guaranteed to have a performance penalty, (yes there are ways to make it functionally as fast as a function call in C) its also false to compare parameterless function calls with virtual function calls (which have an implicit this pointer parameter hidden in the function) because if you start putting parameters into your function you actually start to hit against one of the biggest elements of the performance hit that comes with the virtual function calls. Not the only one mind you, but its already unfair when you don't even compare them on the same level.
"So what exactly is the problem here? In either paradigm you have to change the code. If you add a new operation, in the C++ code you must change EVERY class, including the base class, whereas in the C code you simply add a new function."
Uh no, this is a completely stupid statement for anyone who should know C++. If you override the global new operator you are not required to change any class to suit it, (in fact the only expectation of new is allocating a block of memory) you can, but it is completely unnecessary, and that aside you can override every classes new operator specifically, (technically you are specializing the new function call to the class, but might as well call it the class's new operator) and you can actually accomplish a few different things with this. The same can be accomplished for the delete operator, so not only can you handle construction, but you can separately handle the malloc and free. This is actually quite useful for memory tracking purposes, something you simply can't without explicit calls and control over the infrastructure in C. I have seen libraries use this capability to report/log details of memory leaks without extra debugging tools, its just intrinsic to the program, and its fairly cheap to enable at runtime.
"That aside, what's the problem with changing C's "central switch" and adding an enum value? Seriously. Just change it. You guys use IDEs, right? The year is 2023, you have more tools at your disposal than ever, what is the issue with adding a new enum value? C++ even offers enum classes for better type safety, it's not that difficult."
Sure, the issue is more that its not a scalable solution in itself, its not a big deal, but its completely superfluous compared to any number of superior ways to deal with such behavior, like using variants and the visitor pattern.
"For libraries, which of course you would bring up, you absolutely DO NOT need virtual functions, or C++ for that matter. These are just myths propagated by people who never wrote any serious procedural code."
Virtual is a lot simpler and easier to intuit, it also carries a simpler interface to document and implement, and it actually can be made just as performant as regular calls if you actually knew anything about C++.
1
-
1