This thread has become such a circle jerk (not you necessarily Avaelica, just in general).
On this though, I don’t think the algorithm complexity is the issue at the heart of what the OP is asking/complaining about.
The moment before Tidi kicks in, the client is as responsive as normal. Right at the point where the server kicks tidi in, the performance of the client is affected also, with just the addition of the 1-2 additional objects at the point where the server decides that tidi is needed.
That doesn’t have to do with algorithm complexity and the OP is saying, if the client is going to be updated (ie. 64-bit client to be developed), then can the engine in the client also be updated so that even under tidi, the client remains responsive?
That is, even if the server slows the rate at which it completes a cycle of update calculations, the client shouldn’t be affected by that. The client is still going through its own input, update, render cycle independent of the input, update cycle on the server, so if the server slows down, the client shouldn’t have to. The objects rendered by the client will still update and move slower, but the client itself should still be responsive.
Under tidi however, the client performance breaks in the OP view. It slows down so that even turning the camera becomes an awful experience.
I dont think anyone here will be able to adequately answer the OP since that would require actual knowledge of the code base and whether the affect on the client is a side effect, or a deliberate design decision.
It’s not a bad thing for the OP to ask for though. It would make tidi a much more pleasant experience.
Some people dont even know what is filename extension, so they sometimes remove it accidentally and think the file is broken because they cant open it. Then they send it to me and they are amazed when I “repair” the file and send them back. These are .doc documents or .jpg documents usually. Its rather funny for me when they thank me.
CCP knows better than to open the maintainability drum of worms that is trying to write the EVE server daemon in assembly.
It wouldn’t be faster than something higher level, and debugging would be… yeah, have fun. If they actually tried it, they would have pallets of hair they pulled out because of how frustrating maintaining that much assembly would be.
of course it would be faster. it will always be faster. compilers aren’t some magic software that can replace a brain. on the contrary, compilers make people lazy and people spread the nonsense that the compiler does everything for them, leading to people who have no effing clue why their code is slow and then they need to use yet another tool to figure out where they ■■■■■■ up their code, instead of knowing it beforehand already. thousands of man hours wasted.
of course are you not supposed to write everything in assembly and it’s ■■■■■■■■ to come up with that, but saying that things wouldn’t be faster when you (well, you, probably) write them in assembly is nonsense. programming in assembly isn’t just about writing assembly code. programming in assembly forces you to be wholesome, to take care of things properly without blindly trusting “authority” (the compiler) and about actually knowing what’s going on.
you can claim otherwise all you want. i suggest you take a 10k lines project, have the compiler turn it into assembly and then learn wtf is going on in your main loop, just from reading assembly. and then you’ll eventually start wanting to beat other programmers with a stick, because you’ll learn that most of them are just bad.
Sundays… i love sundays. time for bitcoins! have a good one!
i feel like i went too far with my comment, but in the end it’s just true. me and a friend of mine had to compete with other groups for some NDA work. we got chosen, simply because we were the only ones who got something done in less than a day. really helps when you didn’t have schools ruin you with their crap.
my apologies to everyone who got taught programming in schools. i can not possibly tell you how different it is from growing up with the demoscene in your back, without limitations and “best practises” shoved down your throat.
PS: I use Goto sometimes and Pointers are freaking awesome, even in Python.
Sorry for the necro. Just found this and found it really interesting.
I really love the fact that they use go, which is probably the right tool here as it was actually invented for server side microservices with multicore in mind.
I don’t agree. Languages are all about a good abstraction layer to tackle a certain domain of problems. If your goal is to work with hardware then yes assembly and C may be the right tool. If your goal is to write a microservice which can utilise N cores, has multiple database connections and a built in production grade http server then you don’t use assembly, you use something like GO, which is actually suited for the task and which allows you to write the actual program in your lifetime without having to worry about every register in the CPU.
And yes it would be potentially slower than handcrafting everything in assembler, but I doubt that you could handcraft such a complex program without the need for broad abstract constructs yourself, and then you are basically where the high level language is and sacrifice performance for abstraction and DRY methods so you are still able to wrap your head around it. Just that syntax and the tooling sucks, but some people like it like that
You can disagree all you want. Dunning Krueger. When you write code in assembly, you structure everything around that and write code for your computer. when you write code for your compiler, you don’t. the compiler has no brain. no matter how man years you put into writing compilers, it can not read your mind and turn your intention into optimized code.
the only reason why people think compilers are better, is because they didn’t ever learn to be better, because all they get to hear is to write code for the compiler and not the computer. it’s embarrassing, how several generations have been growing up with the nonsense of OOP being taught as the holy grail (slowing down execution time AND time it takes to write code), and how the are being taught to basically be a servant to a tool (the compiler), instead of using the tool as a servant.
Learn assembly. Spend years with it. Learn how CPUs work. Spend years with it. You can argue all you want, in 90% of the cases will i be able to reduce it to your inability to think in “computer”. the maximum efficiency you can reach is doing it how linus does it, which means using some higher level language, structuring all data properly according to the needs of the CPU (fuck garbage collection) and using assembly inside of it. i do that with every language, even python. you’d be amazed how many shortcuts there are to take.
Abstraction to higher level languages provides efficiency. It isn’t about laziness that people use high level languages as opposed to only assembly or machine.
Chip architectures have their own instruction sets, so writing assembly becomes specific for different target platforms. Whereas, compilers provide a bridge that allows code to be more portable. That isn’t even considering the efficiencies around code readability, debugging, team collaboration, etc.
Compilers (even modern compilers that do optimise how the code is compiled) aren’t supposed to be thinking for the developer. Higher level languages and the compilers associated with them (and interpreters for interpreted languages) make it easier to be productive.
So it’s horses for courses. Embedded systems? Assembly is often a good choice (and widely used still). Applications that work across a number of systems, it’s not so simple.
Efficiency in terms of writing code, at the cost of understanding what it does on the low level. that efficiency gets thoroughly annihilated as soon as people start writing everything in OOP. Plus, assembly has the advantage that it’s faster to read, because 1. VERTICAL SUPREMACY (sorry ) and 2. because it’s straight forward once you understand what the small chunks actually do. Vertical readability of small chunks is much easier on the head than long, complex lines of what is supposed to be easier to understand.
there is a shortage of good programmers not because programming is hard, it’s because programming has moved far away from the computer. most people suck at it, give bad advise and don’t teach you how to code for the computer, they tell you to let the compiler do the work. if that doesn’t tell you that something’s wrong, then i can’t help convincing you
I’ve been looking for simple head tracking module in python. movement of the head and being able to follow eyes was sufficient. where ever i’ve been looking, everyone uses opencv, a 200+ meg download. after a day of bitching about it, i wrote my own in python and assembly. it grabs the livestream of a webcam the image, spreads it across available cores, filters out what doesn’t move and turns the rest into motion vectors. it even recognizes the eyes by default and can do blink recognition. just python and assembly. and it’s much faster than what i’ve found, too! 60fps, smooth as a baby butt. if i knew where i uploaded the video i’d even link it!
i’m a bittervet. i’m coughing green slime right now (much better already) and i’ve developed some serious hate against the western, “modern” way of living, which makes people dumb, soft, weak and disconnected from themselves and their nature. you’re from NZ, you probably understand at least a bit. just let me live in my cave yelling at kids who take a peek inside.
First year university systems organisation and architecture subjects begin teaching how computers work, at the register level, buses, caches, secondary memory, io, etc. Depending on whether you progress as an engineer or computer scientist, there can be an extremely strong focus on understanding how computers are organised, even for people who will never work in assembly in their career.
Computer chipsets, the various flavours of ROMs, graphics cards, etc. are still designed by humans.
Nothing about using a higher level language implies a lack of understanding, but neither does a lack of understanding of those issues mean that someone can’t understand how to optimise code where it is critical to do so (though the more someone understands about the principles of computer organisation, the better off they’ll be).
We all have our preferences and biases though. Can’t begrudge you yours. I’ve certainly never met a good assembly programmer that didn’t understand how to get the most out of their system (though I don’t know that many these days).
And still, if you dig into it, you’ll find out that the vast majority of people who have a title that calls them programmers absolutely suck at actual programming. It doesn’t help if they teach them low level stuff, when that doesn’t actually gets properly applied later on.
instead we have garbage collection, at least one generations of people who think pointers are evil, several generations who claim that the compiler optimizes all code anyway, almost all generations thinking OOP is the way to solve every problem, and an to me unknown amount of generations who think self modifying code is evil and too complex, despite being the holy grail of performance, and i did it on the x86 platform and the nintendo DS (which has two ARM CPUs).
■■■■ University. Those who actually made something non-mediocre out of their lives skipped it, and i bet you know why that’s the case!
things aren’t rocket science, including writing assembly code. people are simply taught to think stupid. we all get born as gigantic geniuses, and the systems we live in turn us into stupid, mindless, consuming workslaves. i don’t need to prove that, because it’s self evident. just look at reddit or this forum.
gee, this ranting really helps. great boost for my mood and immune system! a bit general anger is healthy, as long as it’s not targetted at anyone specifically. it even improves posture! thanks for letting me vent a bit.
I don’t know. I think there are examples all around, from completing a formal education, to those that find a better way for them. There’s no single approach, other than being naturally inquisitive.
So for every uni dropout like Gates, Zuckerberg or PhD dropouts like Brin and Page, you have those that completed degrees and have led the World as well.
Berners-Lee, Dawkins, Goodall, Hawking, Penrose. All contemporaries that have made something non-mediocre and/or made fundamental discoveries that others have applied.
No one path and if it wasn’t for the work of people like Denis Ritchie (RIP), Ken Thompson, Rob Pike, Guido, Linus, Stroustrup, Backus (all of whom completed university degrees to my knowledge) there wouldn’t even be the opportunity to call so many people terrible programmers, because computers would still be stuck in the 1960s as far as application development goes.
I think that’s one of the greatest achievements of computing actually. Coming from a physical sciences background originally, it’s near impossible for a backyard scientist to advance our understanding and achieve what a classically educated scientist can achieve in terms of scientific breakthrough.
However, application development has been demoncratised for the last 30 years. Anyone, educated or self-taught, can excel in the field, however that is to be fair, all built on the back of a very good fundamental understanding that universities provide. Instruction Set Architectures that anyone can use if they want to write in assembly, are overwhelmingly created by engineers/scientists that are classically trained.
Wow, that’s probably not how you pick up a conversation if you are actually interested in a discussion.
Really, is the computer the focus? Do you write code to please the computer or the compiler? Not really right? You actually write code to solve a specific problem and depending on the problem it may actually be a computer specific one and then I agree assembly and C is the right way to go since they are close to how the hardware works and that is what you want.
But there are not only computer specific problems. People actually create programs to tackle all sorts of complex domain specific problems which have in itself a big complexity and have nothing to do with the computer they run on.
The whole purpose of a higher level programming language or any amount of libraries or frameworks on top of them is to groups of abstract of already solved and implemented problems away. And on top of that one language may allow you to structure and describe your complex problem in a way that is more readable than it would be in another language based on what the domain of your problem is.
That is all there is! It’s just abstraction layers to hide complexity. I’m not sure why you think it is something special to know and write assembly. Even in assembly you rely on libraries and abstractions to tackle specific problems and don’t always reinvent the wheel and now tell me how that is different in any way than other forms of abstraction than a compiled language, which in the end are just ways to wire those very same libraries with a different syntax.
Linus writes an operating system and the BIG majority of the Linux kernel uses C and the reason is obvious. It abstracts away the machine specific differences and lets you code in a hardware near environment without the worries about how a specific processor instruction set looks like. Assembly is only ever used to address hardware specific stuff where it is inevitable and not just because of performance. Because it breaks portability there is another cost than performance and that is often much more important, it is maintainability.
Linus himself once said that C for him is just a form of platform independent assembly.
Why do you have an issue with OOP specifically? There are many ways to structure code, and OOP is just one way to think about organising and grouping data and code together is logical segments and model their interactions. There is nothing special about it code wise, it is just a tool to model complex systems. It has absolutely nothing to do with code efficiency.
No, there is a shortage of good programmers because most people are idiots and there are only ever a handful of people who can really understand stuff and wrap their head around complex issues or come up with new solutions or new ways to look at things.
Seriously, most of the time there are more important problems to solve than counting pointers. Apart from that you completely ignore a whole range of security issues manual memory management opens up.
Performance is not the only thing you have to think about when managing your memory manually, people forget that all the time. This is exactly why we have such fragile systems with security issues being discovered every day. Classic programming languages including C and C++ leave all those things up to the programmer and no matter if you understand how the processor and it’s register work, that does not make you an expert on all the different attack vectors you have to consider when writing your code.
