Jon Blow was right.

>he made and sold something that works and that people liked
That applies to Blow's games too

>made
Stole infiniminer

>Results are the most important thing
survivorship bias

Would you rather take programming advice from Carmack or Notch? That kind of mentality means you'd take Notch because he made the most money. The guy who made WORDLE was a first year student and sold it for a million dollars. That's a project tons of people could have implemented if they had the idea. Is he a god programmer for having the idea?
The point is that it's silly to use money as a proxy for programming credibility. "Getting results" has more to do with business, economics, and timing than programming ability.

Carmack: 1 million made per game
Notch: 1 billion made per game
i.e. Notch is a greater programmer

Donald Knuth is a serious academic, maybe even programmer depending on how you define things. He is not a serious developer.

Carmack also made his millions in the 80s. You’ve gotta adjust for inflation if you’re going to go full moron with this example.

If i needed to do something as extreme as to squeeze out ever bit of performance out of P4 for software rendering for Q1 its carmack, if its just getting shit out of the door and getting youtubers playing it (java was enough to mesh the voxels and get it running on the browser) its my bald swedish gay that is telling me what to do, all in all its a shit analogy because everything depends on the context and you picking the right tool for the job depends on your competence level. Carmack said on so him self on lex slopcast

>Would you rather take programming advice from Carmack or Notch?
I would take advice from either of them depending on the situation. I have communicated with Carmack over email before, and for things such as

If i needed to do something as extreme as to squeeze out ever bit of performance out of P4 for software rendering for Q1 its carmack, if its just getting shit out of the door and getting youtubers playing it (java was enough to mesh the voxels and get it running on the browser) its my bald swedish gay that is telling me what to do, all in all its a shit analogy because everything depends on the context and you picking the right tool for the job depends on your competence level. Carmack said on so him self on lex slopcast

has said, he is the man to talk to.
If I wanted to talk about game design itself, I would talk to Notch.
You are being obtuse and creating an arguably moronic strawman

> There are people who are better than Notch at game design as well but you've never heard of them.
Because they, ironically, probably haven't shipped anything of note. You are the one that has brought up money. Notch could have open sourced Minecraft for all I care, and I would still value his opinion of some no name homosexual on this website, least of all (You)

And they are still no name homosexuals who couldn't turn a profit from their abilities. Just this fact alone means their opinion is worthless if they can't derive a few bucks from their supposed "skills".
Money creates status. I know this is hard for you to accept.

notch kept browsing IQfy for a while after minecraft became successful, hence his "problematic" phase. sometimes he used to even post under a known tripcode (maybe you can still find the tweet proving that it's his)

blow has a knack for making superficially unimpressive games that turn out to be complete bangers:
>braid: lmao 2d platformer mario clone there aint no point
>witness: lmao cereal box maze walking simulator game
both of those games did very well and are widely respected as being really high quality and full of interesting ideas.

soulja boy was having fun thoughever

yo bro, the homie liked it so much

Oh no anon, you praised something. You’ve called out all the shitters who wouldn’t dare say they like something.

>complaining about this on an east german messenger-shooting forum

You can make a game in pure css because its turing complete
https://speckyboy.com/pure-css-games/

>it's actually real
Holy shit. Completely proves OP's point.
If you can make a massive success game with JS, rust trannies should seriously invest in rope.

rust friend... did you even read the reply chain? they were using it before it was even standardized.

GIVE UP, BRUCE.

>they were using it before it was even standardized.
Just like companies using Rust now...which then proves it is a practical language by your logic. Thanks for the confirmation

I feel like C++ (and C for that matter) are practical because they allow you talk to hardware implicitly through "unsafe" pointer access. Want to allocate a shared DRAM/GDRAM buffer? No worries, just call this OpenGL function.
I've never understood the whole "borrow checker memory safety" bullshit that moronic Rust advocates (usually trannies) espouse. Either you shit, or you get off the pot, there's no real in-between.
If I'm going to be slowed down by some moronic Rust construct, that's the total opposite of streamlining my development when I could just log/set breakpoints in my C/C++ code and work out what happened instead of insisting that the compiler hold my hand like I'm a moron or have a brain addled by sex hormone injections. The same goes for embedded where you do MMIO every second function. What's the point if I've got "unsafe" littered in my code? It's like using a sledgehammer to nail a fence together.

it's practical because it has 30 years and millions of man hours put into tooling to make it work, nothing inherent with the language

No, it's because it literally "just works" without anything getting in the way of the developer

I wonder if this comes from the fact that proper debugging skills aren't really taught any more. Everything is so large and abstract now, that doing any sort of debugging for the average programming socks wearing zoomzoom triggers their anxiety
Back in the 80s/90s, systems were small enough you could debug the whole thing to gain some understanding. Now they feel like they need the compiler to hand hold them while they develop, instead of relying on something like warnings, static analysis and an actual fricking IDE lmfao

i will use a compiler that can solve issues at compile time instead of using a debugger or sanitizer every single time

for me, the cost is worth it because i spend less time debugging than i do in c++

i have personal experience that contradicts the blog, i know you have no experience whatsoever

no clones, just original utilities that have a bunch of downloads

i've also worked on games in unreal and unity

my experience in games and writing rust leads me to different conclusions than the author. rust is a force multiplier for me because i know how to use it and plan out my systems. i'm not doing massive refactors constantly like he was because i sit down and think about the problems i want to solve before hand, have a scope that i won't expand, and then i execute the plan

>that results in bad games, you really need to iterate on things
nowhere did i say iteration doesn't happen. you can still iterate within the confines of the scope you've set up, and then iterate on more ideas in your next game. getting the feeling everyone else here is larping about writing games...

The belief that "all issues can be solved at compile time" is a dangerously naive assumption to have. I strongly believe that a large uptake in rust will actually generate significant security holes in software if people programming rust genuinely believe this.
You should always be skeptical of the compilers output.

>dangling references
that was not even the problem that was described lmao midiwit

in c this is just
struct Character {
char* name;
};

struct Context {
Character* selected_duck;
int other;
};

void character_select_duck_detail(..., Character*, Context*);

void Update(Context* context) {
if (context->selected_duck) {
character_select_duck_detail(..., context->selected_duck, context);
}
}

and it works fine!
the problem is that rust's borrow checker is not sophisticated enough to realize when aliasing is safe.

Hi anon, brainlet here. Can you explain to me what this code is able to do that Rust can't? I don't know any Rust at all, but this C snippet is something quite simple. What's the problem with Rust when trying to rewrite this?

I dont get it, where does it happen?
(..., context->selected_duck, context)
or
if (context->selected_duck) and (..., context->selected_duck, ...)

Frick Rust then lmao, I am happy in my simple C world

you are a midwit!

>le nocoder has arrived

C has allowed weak programmers to push security nightmare after security nightmare for almost 70 years with no social repercussion

>>t. never had to write truly high performance code
cope harder, midwit

>no reply but harder cope
yep

People seem to have forgotten that we need "unsafe" code to do anything useful in systems programming. It's no surprise that there's unsafe C-style code sprinkled throughout the entire standard library, that's practically a requirement.

However, Rust is the only systems language that gives users this dangerous false sense of perfect security. Those buffer overflow CVEs from the standard library are just a consequence of their own arrogance.

They literally do. They have used and continue to use "unsafe" languages. But they look for a minimum skill level and have standards, and the code must meet those standards in review.

Unless you're modern Boeing. Then H1B pajeets can write the software and have it tested in India and then the planes can crash.

give up bruce. rust lost. cniles won.

y'know maybe this wouldn't be such a big deal if there was a fricking standard instead of just an implementation

>having to drag CVEs from 3 years ago
raise

>I never said it wasn't less likely in a "memory safe" language. It is.
backpedal
>So if you assume that your code is "safe" because of the language not only will you get your ass bit by the other types, you might even get bit by the type you believed could never happen.
did anyone claim otherwise?
try asking for unsafe rust help on the usual places without reading the unsafe docs, you will (rightfully) be yelled at

here is an example of the type of problem rust's language design is centered around preventing:
std::vector<int> xs;
xs.push_back(1);
int& ref = xs[0];
// can segfault: xs was moved in memory after resize, we're accessing stale memory.
xs.push_back(ref);
xs.push_back(ref);
xs.push_back(ref);

the way rust does this is by making mutable references exclusive:
let mut xs = Vec::new(); // 1.
xs.push(0); // 2.
let refval = &xs[0]; // 3.
xs.push(*refval); // 4.
xs.push(*refval); // 5. <- compile error! xs borrowed in (3) and used in (5), but was also borrowed mutably in (4)

what it is doing is preventing you from aliasing a value. this means your code can't hold more than one mutable reference to a thing simultaneously.

the analysis that rust is trying to do is fundamentally conservative.
if it can't prove that your code is safe, it will not compile it; as opposed to refusing to compile when it can prove that your code is unsafe (much, much, much harder).

so in some cases, you might have aliasing that is perfectly safe to do when taking into account what the code does but rust will just refuse to compile the code because it conservatively rejects all mutable aliasing.

in this specific case, the author presumably wanted to borrow a struct mutably whilst also borrowing one of its fields at the same time.

>the problem is that rust's borrow checker is not sophisticated enough to realize when aliasing is safe.
Bingo. I don't even have experience with Rust and when he started to describe that problem I intuitively understood where he was going. But that goes against the Rust narrative so it has to be mocked rather than understood and acknowledged.

I'll defend C when brainlets attack it on IQfy. But I would never, ever suggest it for everything except as sarcasm. I don't deny that it has problems, in fact I fricking hate null terminated strings (though if you're using C to accelerate string processing you simply don't do it that way and ignore standard library string calls). But C has its strengths and its place. Rust (and some Python) evangelists just can't admit the language is not perfect. Criticism and using another language literally triggers them.

There are no perfect languages, frameworks, etc. Use the best one for the job.

basically yes. the correct answer is the boring one. just evaluate requirements and use the thing that's suitable for the task. then nuanced part is knowing how to evaluate requirements and correctly pick the tool in an objective way that's not influenced by hype or emotion.

I absolutely love Linus, and you forgot to include the explanation.
Also Rust still doesn't have a stable ABI and probably never will, so why the hell are they trying to push it into the Linux kernel?

for Linus, its just that kids don't wanna learn C and wanna learn Rust because its the cool new thing. Despite google's shilling he has no delusions of Rust's safety like the cargo cult does. He just supports it because eventually the current gen of maintainers will die off. And tbh, from what I've seen of zoomers, they are all utter morons so I don't blame him going after the Rust community. They tend to be filled with troon autists but that's still better than the average CS grad these days

Linus is such a bigot.

>rust is a huge pain in the ass to deal with but also it's a crutch for brainlets
You don't like change. Man up and admit it.

> Most don't believe "unsafe" code should be used at all.
Yes, which is why when confronted with

People seem to have forgotten that we need "unsafe" code to do anything useful in systems programming. It's no surprise that there's unsafe C-style code sprinkled throughout the entire standard library, that's practically a requirement.

However, Rust is the only systems language that gives users this dangerous false sense of perfect security. Those buffer overflow CVEs from the standard library are just a consequence of their own arrogance.

they earn their status as a… cargo cult
If unsafe is considered harmful (TM), then the STL shouldn’t use it, Rusttards unironically act like cult members trying to explain why they need to be celibate but the Supreme Leader gets to frick four chicks a day

>a small part that experts write and application developers
Do you even hear how ridiculous your own propaganda sounds?
Rust is a systems programming language, not something you'd normally use for user applications. There are better languages for that that are easier to write in and with much better GUI support.
The only reason rustroons keep pushing for Rust outside of systems programming is because it hilariously failed at it with its safety at all cost obsession.

>trannies aren't real
Now we're agreeing. They're delusional.

Simulation games made in those engines run better than Paradox's pieces of shit

>Endless Legend
lol what, it's turn-based
>You're probably looking at older single-threaded Paradox games
I'm looking at HoI4, runs like complete dogshit
If you want a deterministic sim you can just use integers

Nah, it's better then C# for sure.try programming in it. It is extremely trivial.

What’s so better about it? Honest question. No MSFT baggage?

It doesn't follow OOP dogma.

The language haa been designed to help you write faster code, plus it share's a lot of great things with C, plus the standard library is head and shoulders above other languages.

That can be said for a lot of features. You failed to make a case for their inclusion in Go. Let alone a point at all. Dynamic types with defined interfaces have proven to be sufficient for over a decade, and the addition of generic support doesn't seem to reflect the importance people implied it had when they where complaining about it for that decade.

>need
For what purpose? I strongly doubt you have a collection of arbitrary data that is so generic there is no commonality amongst the objects that their behavior can't be described in an interface. It's more likely your abstractions and control flow is terrible.

I fail to see why you can't just have a slice of an interface which has methods that defines the common behavior they have.

That doesn't change anything. I'll write you a contrived example.

I don't get what you're talking about, especially without any code examples.
You can define a method on a slice of ints and bytes, describe the commonality between them, and utilize the interface type regardless of the underlying type. The same can be done for a slice of slices if that's what you're doing.
https://go.dev/play/p/DJfxBLy0MfH

This applies for things like encoding too. Even if you have different underlying types, you're still going to funnel towards some common behavior somewhere, like encoding a collection of items to a byte sequence before writing it to disk or the wire, it doesn't matter what their underlying type is as long as it has some common interface. Which you're going to need anyway if you're passing around generic types and doing the type discrimination and dispatch manually.

>You've gotten around this by making an interface to either an array of ints or an array of bytes
You specifically said

Ok I have a vector of ints and a vector of bytes
They're exactly the same thing except they contain a different data type
How you gonna do that without generics?

>I have a vector of ints and a vector of bytes
So that's what I used. And
>How you gonna do that without generics?
I showed you how.

>But what if you want to make a generic data structure that could hold an int, a float, a struct, or whatever
Nothing prevents you from using the interface type as the type of your struct's field.
>and the underlying data structure would actually need to change based on what type it was holding?
You'll have to explain why the struct "needs to change" based on what type it's holding, because that sounds like fragile and bad design.
Again even in situations where a types size matters, that is easily abstracted out.
And to reiterate, if you're in that situation already and not utilizing an interface, it implies you're doing the same thing somewhere anyway, but manually. There's no reason I can think of to do that instead of allowing the language and compiler to aid you here.

>I'm asking you how you would IMPLEMENT a vector of ints or a vector of bytes, you're using the existing implementations
The same principle applies. Now the question is why you're choosing such an example. Because there are theoretical problems and real problems, and choosing to implement your own vector of ints seems like a contrived problem made up just for argument sake and I don't want to have that discussion.
I already showed how you can have a vector of arbitrary types so long as each type within the set conforms to an interface's method set.

>I'm assuming the interface is a tagged union so it would be the size of the biggest option
It's tagged, but not a union. It's a type descriptor paired with the data. So if your interface implementation is a slice of ints (a pointer to an array), then an interface value holding one is the type information and the slice itself.

>Performance
>You can implement everything via dynamically typed interfaces, but you're wasting memory and execution time
Without any measurements you're simply assuming. I can just as easily say the the cost of doing the discrimination and dispatch by hand is equal or more than the time it takes for the runtime to do it, if the compiler hasn't already optimized the dispatch out.
The same can be said for memory usage. Without measurements you're just assuming.
Considering what you've said so far, I wouldn't be surprised if your structures are suboptimal in that regard. Not to small size not being important on all architectures. Alignment typically matters more, but as always you have to measure on your target machine to find out.

Yeah you don't need to implement a vector yourself, but you have to implement more complex and specialized data structures yourself, I chose a vector because everyone knows what it is
>Without any measurements you're simply assuming
It's the way computers work. If you want a vector of something that might be an byte (1 byte) or an int (4 bytes) at runtime, it's going to be at least 4 bytes per element, which is going to be wasteful
And dynamic dispatch is slower than static dispatch, this is fact
>I wouldn't be surprised if your structures are suboptimal
This feels like a strange thing to say, you're advocating for suboptimal data structures

>I already said that's not the case. It's not a union.
You said it's a "type descriptor paired with the data". That's a union. What else could it be? These are the fundamental rules of reality, you either have compile time generics or you're wasting extra space accounting for any possible value. You don't need data for this, it's a logically provable fact. The same way that dynamic dispatch is slower than static dispatch, more work needs to be done at runtime

>And I'm saying this with utmost confidence because we've had several decades of people saying shit like "you can't write games in a garbage collected language!" yet here we are where there's many many successful games without performance issues implemented in Java, C#, JavaScript, et al.
More importantly we have the opposite case where games written in C++ from AAA studios run like absolute dogshit. The language matters less than the implementation of the game.
A recent successful game Balatro is a Love2D game (Lua game engine) and from what I heard the implementation isn't the best, yet it runs fine.

>You specifically eluded to the C type of union where a type is as big as it's largest type
That's how it HAS to work, there's literally no other way to do it
>First you said it wasn't possible
Generic data structures aren't possible. This is a non-generic data structure that operates on generic objects. Generic data structures need to be able to change their data representation based on the generic parameter

You can write games in Go or C# or any garbage collected language, it's perfectly fine for many tasks, but if you want to do anything that deals with primitive data types or has high performance requirements you're going to have issues. You can't optimize interface dispatches very well unless you're willing to generate different function variants for every type

>le business CRUD developer handling 2 pieces of state at a time think he's better at making video games that juggle thousands of pieces of independent interacting state at a time
the reason video games are buggy (not unlike other software) is because they're really fricking hard to make.

what doesprogrammed "badly" mean? does it not mean worse relative to other software? my point is that you coudnt do better.

>a pointer to the underlying value
Having a pointer to a byte stored randomly in memory is WAY worse for performance
>Now you're going on about how they might use more memory in a hypothetical program that doesn't exist and we can't measure
I gave you a concrete example
If you have a generic array that can hold a byte or an int, it's either going to have to allocate enough memory for the maximum size or it's going to be a pointer to some allocated block of memory somewhere else which is way worse
>I'm going to back out of this discussion with you.
This is always what bullshitters say when they're on the verge of having to admit they're wrong about something

If it a list of interfaces to a byte or an int, that interface is going to be fricking huge and slow compared to just a byte. That's what you need generic data structures for
You cannot compare an interface to a byte array or int array to an array of interfaces to a byte or an int, these are not the same thing

>This is always what bullshitters say when they're on the verge of having to admit they're wrong about something
Sounds like your way to cope and/or projection. Sorry I ran out of patience with you bro.
It just seems like you're genuinely not able to grasp the concepts so it's not worth talking to you about it.
Remember, it's not my job to educate you, and I gain nothing if I convince you of anything. And it seems like you've made up your mind and are trying to go in circles or divert to another topic, so it's frustrating to talk to you. Sorry man, it is what it is.

>evidence suggest that lots of AAA games don't even function properly, let alone are they programmed well or in some optimized way.
Having bugs is a completely different ballpark to not running well, every program has bugs

I fail to see how any program that hardly functions isn't somehow "programmed badly".

what doesprogrammed "badly" mean? does it not mean worse relative to other software? my point is that you coudnt do better.

>my point is that you coudnt do better
Whether this was the case or not wouldn't change the fact or somehow excuse them.
Me being worse at something wouldn't somehow make their results acceptable. That's a horrible argument.
In any case it didn't convince me that they're programmed well or optimized. Neither of them.

Actually laughed at the irony of this post. I suspected you were trolling and this part specifically confirmed it
>All programs have bugs, there's no game released that "hardly functions"
GG you tricked me.

>You're being a typically confident ignorant, close-minded idiot and refusing to engage with any facts.
Bro, I replied to you like several times. You're not even being fair. I'm not reading the rest if you're gonna act this way. It just reinforces my judgment that it's not worth it.

Every AAA game does it just to get their games to run

That's a generalization that can't be substantiated. You're clowning if you think all AAA games are releasing in some optimized state.
Which isn't the argument regardless.
The original point is that the timing difference between languages is not likely to be the primary cause of your suboptimal performance. Everyone jumping out of the woodwork to defend AAA games as if this will change that fact.

literally every game using unity is a direct benefactor of this fact. the engine is very optimized so that people can do scripting on top of it.
likewise for unreal.
and of course every single custom engine.
go watch a siggraph or gdc talk bro.

That changes nothing. An optimal engine doesn't automatically equal an optimal game. You can surely find countless examples of people using an engine poorly.
I like the game The Citidel, it uses the Unreal engine. It's comparable to Marathon in terms of looks and gameplay.
Yet randomly sometimes a level will load and you'll get single digit FPS. Sometimes you don't.
This isn't the engine's fault, the game developer is likely doing something wrong on top of it and tanking performance.
So not only did he not write the engine, nor optimize it, he managed to take an existing engine and have bad performance arbitrarily too. So what difference did it make?
This happens in AAA studios all the same.

>refusing to engage with any facts
>>Bro, I replied to you like several times
>So?
Are you actually moronic?

I can't tell if you're joking or not. The irony is too thick.
Regardless, if you're going to be this persistent let's get to the bottom of this.
You should either
1) remain confident in your own perspective and walk away knowing you're right
2) look into an alternative on your own instead of asking me specifically to change your mind when that hasn't worked so far
You're clearly not understanding what is being said, you also don't seem to want to change your mind, I've made it clear you're a pain to talk with, and you're still pestering me to talk with you.
Sorry if I hurt your feelings or whatever, I'm just being honest with you. If you're seriously interested in the topic, look into it on your own time or ask someone else. There appears to be at least 3 other people replying to you and they didn't make any progress either, maybe someone else will continue the chain.

yes, i agree indie games are sometimes badly optimized, this is pretty obvious given that they are often made by people who aren't even programmers.
>This happens in AAA studios all the same.
this part makes absolutely no sense. the only performance-related thing you can criticize AAA games for is the shader compile stutter. and even then, to be fair, this is a mix of modern graphics API being truly braindead and developers not wanting to use ubershaders because they sometimes just can't effort the perf or flexibility loss.
there is very little other software that comes even remotely close to AAA games in terms of how well it is optimized.
[...]
classic rust mentality. "you're not supposed to want that"

You're reducing things too hastily and then generalizing too. Shaders are not the only thing that could cause performance issues and not all studios are going to produce optimal works. I can't believe I have to write something that obvious.
And again none of this has to do with the original point that the difference in language isn't going to be the significant factor in your game's performance. The point made was that even AAA games written in C++ can have bad performance. Are you really trying to argue that can't be true? I'm not convinced.

>difference in language isn't going to be the significant factor in your game's performance
you need a language that gives you low-level control over memory and has no gc. just because some games have manged to scrape by without this, like minecraft (still experiencing perf issues to this day despite their voxels being insanely low-res) doesn't mean that it is not true in general. in general, you would prefer a high performance real-time language.
of course, you can write slow c++ if you're bad at programming or just don't care, but the perf ceiling is way-way-way higher than in any managed language.

yes, you can make a game without a systems programming language, but it will be a lot slower than what is possible.
if you make a game with a systems programming language, it is highly likely it will be less slow unless you're very bad at programming.
all non-trivial games, no matter the language they're made in, will have to be optimized to fit in frame budget. whether it is by cutting features (minecraft runs on a 20Hz tick and has 1 meter voxels) or by writing optimized code (see https://www.youtube.com/watch?v=6BIfqfC1i7U)

in the end it boils down to this boring set of statements.

I'm not reading that. I don't know why you think I'm going to engage with the technical discussion after stating several times I won't, including the post you replied to.

I appreciate that you write out the projections, it makes it very transparent and provides useful insight. I'm not kidding. The psychology aspect of this place makes reading rants worth it. Like a kind of exercise.

The claim was this

That can be said for a lot of features. You failed to make a case for their inclusion in Go. Let alone a point at all. Dynamic types with defined interfaces have proven to be sufficient for over a decade, and the addition of generic support doesn't seem to reflect the importance people implied it had when they where complaining about it for that decade.

which you argued against here

>Dynamic types with defined interfaces have proven to be sufficient for over a decade
No they haven't, I need static generic data structures, so does anyone else making a game

but now you seem to agree with me.

You're changing the narrative by saying your claim was
>I claim you can't do <Byte,Int>[] efficently in a language with no generics
when efficiency was not part of the original claim, and was something I pointed out earlier.

You specifically eluded to the C type of union where a type is as big as it's largest type which is not the case here. For Go specifically the interface semantics can be implemented however the compiler wants, as long as it conforms to the spec.

Regardless, you're still driving off topic. First you said it wasn't possible, now you're just saying you're not satisfied with it.

If you want to argue about the hypothetical difference in performance, we can do that.
Go might not be the fastest language but it's usually ranked pretty high. And it allows you to interop with C code, as well as implement functions in assembly for really-really hot paths if that's your requirement. There's also several implementations of the compiler, including ones for embedded and high performance systems.

If we're going to pull numbers out of our ass, lets assume your game is nanoseconds slower on average. Unless you're Grace Hopper's ghost, it aint gonna matter. And I'm saying this with utmost confidence because we've had several decades of people saying shit like "you can't write games in a garbage collected language!" yet here we are where there's many many successful games without performance issues implemented in Java, C#, JavaScript, et al.
The language is not going to be your performance bottleneck, I promise. If you write it shit enough in Go that it causes frame rate issues, you're going to write it just as shit in C.

This is important to remember for this topic too because far too often do people get tricked into using languages like C and writing their engines from scratch and they never ever just make the damn game at all, let alone a performant one.

>Regardless, you're still driving off topic. First you said it wasn't possible, now you're just saying you're not satisfied with it.
Not to mention the disagreement you're hung up about, seems to stem from a reply you made to another Anon, but you're asserting it was me and getting mad at me for it.

>but when you need the performance you need real generic data structures
You don't "need" them to have performant programs. This is yet another vague statement about nothing. No context, no metrics, nothing.

I'm not even sure what you're frustrated about. I have doubts it actually relates to our discussion.
If you want to talk about it, I'd rather read that.

And your claim was incorrect. You don't "need" them. You seem to think you do, and that's where we disagree. You also seem to think there's only one way to implement such semantics which isn't the case.

>How do you know what I need or not?
The better question is, without measuring it, how do you know? You're claiming it's not performant enough but present no metrics and no implementation to compare. It's a baseless claim along with requirements that are not presented.
>There is one practical way to implement it
You learned about one implementation in this very thread, today, and now you're claiming there's one way to do it. You're ignoring compile time elision as well.

Your entitled to your opinion, but at the end of the day you did not convince me that generic types are a requirement for game development. Without any data to back you up, you're just saying you need them because of some imaginary benchmark you've made up in your mind. "that's just how computers work", that's not how engineering works. Either you have the proof that it can't render frames fast enough for your target, or you don't.

Until you have real numbers from a real instance, it is what it is, pulling numbers out of your ass. It's baseless, made up numbers in a made up language that you don't have a working implementation in. Anything else is just self-convincing.
It doesn't even address the fact your requirements aren't stated. Even if we assume it's less optimal, the question is if it's within the window of acceptance. Can you make a game in the language and can the game run on the specs you intend. Most likely.
The reason you're saying it won't boil down to "trust me dude", and "I can't think of any other way to implement this so I just assume it won't work". As well as a potential unrealistic standard like trying to get the thing to run on ancient hardware or something esoteric like that. Which at least would be somewhat valid.

Obviously I meant the 1GB figure, not the 100. Unless you're saying you have 2 implementations and did compare them.
If that's the case, you should post the latter because I'm willing to bet you're doing something horrendously wrong to get such a delta. Especially if we're talking about Go which DOES have generic types that you can use if somehow that proved to reduce the memory significantly.

So the numbers aren't real...and doesn't even have anything to do with the language we're talking about.
Didn't implement anything, didn't test anything, didn't measure anything. Just came up with some scenario and asserted it to be generally true.
The only reason I was asking was because I thought you had a real problem you didn't understand and could use real help with it. But you're just making shit up to argue about for no actual reason. That's wild.

The math being correct has no bearing if we don't even know what the implementation is being written in, let alone how it was compiled. This is the entire point of why you measure things. What you're doing is the equivalent of reading a C++ function and trying to tell me what instructions it will compile to and how much time those things use on a specific CPU. The issue here is that without actually running it through the compiler, you're speculating. You don't even know which compiler is being used, which optimizations are being performed, etc. This is why it's important to have REAL numbers, not made up statistics. What you're doing is, yes, actually, speculation. How you're still arguing that is baffling.

>Please be honest instead of patronizing
You're the one being dishonest. You ask and ask for me to engage with the problem when it turns out there was no actual problem. You just made it up. And asked me to engage not because you needed any kind of help, then for what reason? You finally get what you've been asking for and then get mad about it and call it patronizing.

It 100% matters. Without knowing how the program is even going to execute we don't know shit about it. The numbers you're inserting are literally made up. You have no idea how much memory it's going to use at runtime because you never executed it. You're just assuming some worst case scenario because it's what you assume to be the case, in some hypothetical language. That's nonsense.

>I never said there was a problem, I'm just trying to tell you there is indeed a use for generci data structures
I never said there was no use for generic data structures. I said that Go did not need them for over a decade and now that it has them hardly anyone uses them despite the disproportionate bemoaning.
If there was no real problem to solve and you didn't care to learn about the language, I don't know why you were so incessant on asking for answers to things you have no experience nor problem with. I assume it was just to pass the time?

>There are logical constraints the language must obey
>If you're using your generic array to store 16 byte numbers
This is a constraint you are imposing. You made this number up. I don't know why I have to point this out since the source is you.
You have considered 1 approach to solve the problem and you have decided it is a generic one, and that the only possible way to solve it otherwise would be with a tagged union. Not even humoring the idea of any other possibility nor even giving anyone else the possibility to implement an alternative approach themselves, because there actually is no implementation in the first place. It's an incredibly unfair and baseless argument.
There is no code to review and apparently we haven't even settled on a language, so what rules it must "obey" are written in the nonexistent spec. But you've somehow nailed down the specific implementation details in your mind. You're making up these constraints and not even considering there could be an alternate approach that doesn't utilize either method for such a task. While also making assumptions about the width of the data type in hypothetical-lang.

>Never asked for answers
How about you start being honest. Remember when you kept complaining about not being engaged with? If you want to be pedantic, go for it. But you know, and I know.

Originally you asked how to implement something without using generics. Performance was not mentioned yet. An interface solution was presented and explained. As well as how it could be adapted to follow up questions.
You mentioned that performance is required for game development to which I roughly said "so what" because the difference in performance is likely negligible. You have conflated the 2 concepts and still have not separated them despite the fact you and I both mentioned them several times now.

You don't need generics to solve the problem you presented.
Go has generic support so if you want to solve it that way you can.
In either case, it's unlikely that either solution would be unsuitable for use in a game, there is no implementation or evidence suggesting otherwise.
You proceeded to assert that there's only 1 way to solve this and that it would be unsuitable because of numbers you made up for your own arbitrary requirements which aren't even directly relevant. (We should be caring about render time, not memory usage, and the memory usage figure is made up anyway.)
As I said before if you use the generic approach in Go the same as you are in your existing language, the difference in performance will be negligible. And even if you use the interface approach it is likely still going to render at an acceptable framerate, it's not unsuitable for games in either case, and you're not even humoring a potential third case where the code is written in an entirely different way than the original implementation's design (which was never presented nor was an alternative).

>That's not because I wanted a question answered
Sure bud. You just ask questions rhetorically. Totally not seeking attention after projecting "narcissist".

>The difference in perfomance between just a number and a virtual interface to a number is huge,
That's it. You won. I quit.
You're still refusing to acknowledge there's more ways to solve the problem than just one. Despite presenting one yourself.
I concede.

Who cares. Just use C++. It's faster.

What part of "I concede" don't you understand.
You've convinced me that in engineering there's only 1 way to solve a problem and I won't consider any other possibilities. It worked for me once in one language so it's probably the only way to implement it correctly or performantly in every language. There's no need to actually test theories when you can just trust your gut and stick with designs you know will work.
Not even reading what you wrote for the same reason, I just have an intuition I'm right and don't have to back it up in any way. That's what I've learned.

Go has had generic support for multiple years now so there's no reason you have to use interfaces in your structure, but you keep saying "no dude trust me there's no other way to implement it". It's a constraint you made up and it's still the only strawman you want to argue against despite knowing up front that Go supports doing it the exact same way you're already doing it, which is good enough in that case but somehow not performant enough in the other case.
What do you even want me to say at this point? How do I take the L?

>I was just talking about some theoretical generic array you would make with interfaces
Which is exactly my point, it's a theoretical made up problem and you're choosing 1 specific solution as if there's not other ways to solve it. If you don't want to pay the overhead price of interfaces then simply don't use them. Again there's 3 possibilities here but you only ever harped on 1. And constantly deflected to other topics entirely like how every AAA game is guaranteed to be pristine. There's not even a chance even 1 of them could have faults. Not a single one.

The issue you're still not seeing is that you're not even considering other approaches. You posit that it must be either an array of tagged unions of {type;value}, or an array of C style unions. And this is all predicated on your design's implementation details for your game objects in your engine which nobody know anything about. Realistically we don't know if these objects even need to be paired in this way, you're just asserting it as such and with no code examples and no clear requirements or goals, how is anybody supposed to present a counter case.
You keep saying the only way to solve this in a language like Go is to have a slice of interfaces which is just one possibility. The other is to utilize generics the same way you're doing in your existing project. Yet another is to just design the program in a different way if possible that obviates this theoretical constraint you've imposed.

This detail has almost nothing to even do with the overarching topics, which were that Go got by without generics for a decade, and even without them you could make a playable game with it. The fact that you disagree with that premise doesn't preclude the scenario where you make a game in Go with generics or even some other approach that is equally as performant given with respect to differences between the language's compiler/runtime/spec.

I really have no idea what you're arguing that is real and not abstract concepts you've inserted into the argument. There's nothing tangible at all.

>I don't give a shit about Go, according to you it even has generic data structures so what's the issue there?
That has been both my point and question to you for nearly the entirety of our discussion. You keep pretending like the interface solution is the only solution and then go on about how they're not sufficient for you specifically in your specific project with your specific design, to which the question arises why are the other solutions not viable, one of which includes using generics. Every time I tell you "that's not the only way to solve the problem" you just go "trust me dude, it really is". So it's even worse when you present them as a solution after refusing to acknowledge them otherwise.

Since we're on page 9 and the thread is concluding. I'll admit my perspective. I suspect you're either trolling, or you're yet another blub programmer who only has 1 worldview.
In either case, I got severely owned by feeding into it.

This is why I mentioned seeing the output of the compiler.
A generic math function is probably going to generate a finite set of fixed functions in cases where the calls are few and inferrable at compile time, and if you find that to not be the case, code generation in Go is particularly easy using the standard library and the standard tool `go generate`.
The latter of which might be considered a pain in the ass if you have to write the template yourself (it's no different than any other metaprogram), but lots of generators for Go already exist.
For something like math the standard library likely has you covered anyway.
And I mentioned before that it may be such you can better abstract things to not even require so many type dependent code paths. Without seeing real code nobody can say for certain. As-is, I have no idea what you're using your ints and bytes for, let alone their code paths.

>https://go.dev/play/p/DJfxBLy0MfH

>
type (
ints []int
bytes []byte

common interface {
count() int
}
)

what is this construct called? what does it do? I can see it's a sort of list of type definitions and the types in it can be used independently, i don't understand why it's all within one "type" thing

It's just a typedef block. It's equivalent to this
type ints []int
type bytes []byte
type common interface {
count() int
}
)

Go allows this for I think everything except functions. E.g.
var x int
var y int
var (
x int
y int
)

Same for `const`, etc.

>If your compiler is generating multiple copies of a data type or a function, guess what, that's not runtime genericsm, that's compile time genericism
Stating the obvious for some reason. Are you implying it's somehow not sufficient?

>And using code generators is cope
Maybe in languages with bad tooling and syntax.

>This is baby advice
It's good for you. Arrogance is a sign of stagnation in programmers. Thinking you know a solution precludes you from even thinking about alternatives and you've certainly demonstrated that stubbornly today. Be careful with that if you care to.

>Maybe in languages with bad tooling and syntax.
I should clarify that Lispers probably have opinions on this topic too.

>Are you implying it's somehow not sufficient?
I've been saying compile time genericism is useful, that's my whole point
But it's an inferior solution, because usually the compiler can't know what can be made static or not, unless the language has some special compliation model where everything is compiled at once

>Arrogance is a sign of stagnation
You're being arrogant telling me I just haven't thought about the problem hard enough
Like if I disagree with you, clearly I must be less experienced. I've been working around not having generics for like 15 years

I didn't say you were less experienced and even implied the opposite by saying stagnation. Of course you are one minded, stubborn and take offense to it...

Poetically ironic as usual. It was at least half nice talking to you. Goodbye.

lol

Bro you've been talking to me this entire thread about things you don't understand and I do while acting like you know better

You've misinterpreted and misconstrued everything I said. And are continuing to do so.
Whether it was intentional or not, I'm not sure. But I think not considering what you wrote.

Oh, so you do think generics are useful? Then what the frick were you arguing about?

>I never said they weren't
Then what the frick are you arguing about? I said there was nothing wrong with Go like 50 posts ago. Are you having trouble reading?

>you were the one asking me to engage with your posts
Yeah I said that like 100 posts because you turned into a pompous moron as soon as I pointed out you were wrong
Then you tried to convince me I don't need generics for no apparently reason

I pointed out that your example wasn't equivalent and it didn't answer the question
You spent all this time arguing with me about the utility of generics but turns out you don't even disagree
What's the point

>The behavior is equivalent,
its not

I already answered it ages ago
That's the problem, you don't get what I'm saying
I mean I could be clearer but I'd have to write pages and pages, I'm sick of typing already

> I said Go didn't need them for over a decade and hardly anyone uses them.
uses them in Go even now that it has them*

I wasn't arguing, you were the one asking me to engage with your posts while I kept saying you're not making sense and going in circles over multiple things you made up. I pointed this out constantly which is why I thought you were trolling.

To clarify this is also why I kept saying you're misunderstanding and misconstruing thing. And as usual being ironic. Talking about reading problems now, very funny.

>effort the
afford the

>some people do this therefore everyone does this
No.

literally every game using unity is a direct benefactor of this fact. the engine is very optimized so that people can do scripting on top of it.
likewise for unreal.
and of course every single custom engine.
go watch a siggraph or gdc talk bro.

>https://go.dev/play/p/DJfxBLy0MfH

>
type (
ints []int
bytes []byte

common interface {
count() int
}
)

what is this construct called? what does it do? I can see it's a sort of list of type definitions and the types in it can be used independently, i don't understand why it's all within one "type" thing

No I mean writing code to create or change gameplay systems

There are cases where equivalent C++ code is slower. Both languages are roughly same speed in practice.

Yes, exactly due to that.
C++ moves are not destructive, unlike in Rust. That means that shared pointers are always going to have an overhead, while in Rust it is truly zero cost. See the "There is no zero-cost abstractions" talk.

>how can you watch that talk and still call rust shared pointers "truly zero cost"?
Because the cost comes from C++ moves not being destructive. This is not the case in Rust.

>this is more of a standard library issue anyway.
Moves being destructive or not is a language feature, not standard library feature.

>by fundamental language limitation i mean that you just MUST clone the thing to reference the same value from multiple places.
This is not the case in either language.

>i dont think shared pointers were even mentioned in the talk, are you talking about unique_ptr?
You are right. It does apply to both. I just assumed it can't be that bad to also affect unique_ptr but it does make sense.

>and yeah, turns out it's a standard library issue as i said!
Standard library is not the one dictating the kind of moves allowed by the language.

>[[trivial_abi]]
This is not standard, it's from a non standard extension from a certain compiler implementation. It also imposes extra restrictions on how you can use the pointer, which again are not present in Rust.

>the thesis C++ RAII advocates have is that an optimizing compiler can deal with the moves and have them be as efficient as if they were destructive in perf sensitive code
It doesn't always work as illustrated in the talk.

>you can always get the optimal behavior (but not the optimal code
You can't actually, because destructive moves are simply not possible. It doesn't matter if you can inline asm or whatever to avoid the costs, the problem is that this is a fundamental language limitation that introduces costs that are not needed. C++ can't have efficient RAII. If you want your code using RAII to be zero cost you need to get rig of RAII altogether. This is a language limitation.

>assuming there is such a thing as "efficient RAII",
There is in Rust.

>imo RAII is never zero cost in any practical terms.
unique_ptr should not have any overhead over just using a raw pointer.

>the reality is that mallocing and freeing small objects is slow no matter how you put it and you should not be doing it in perf sensitive code anyway.
That doesn't justify the extra costs that C++ adds on top.

>in rust, mutable aliasing is UB and always will be no matter what you do
If you use raw pointers it's no longer UB. It's only UB when using references.

And it's not feasible to switch to raw pointers every time you want to move a RAII pointer to different scope in C++.

Fortunately if your program is well designed, you won't need aliasing mutable references in Rust. This also enables extra optimizations that are not available in C++, unless you mark them as noalias which no one does since it's like a walking on a minefield.
However, moving smart pointers around is very basic operation that happens all the time.