What happened?

What's up with the community changing from making easy to read and efficient code, to becoming speed freaks, where you would add one hundred extra lines of code for a fraction of a second of improved speed. There's so many spells being declined from being introduced into the community because of very minor things, moderators are becoming power-hungry.

When you move into a career are you going to be coding in assembly or simply learning machine-code, because that's the direction you're heading.

Computers are improving every day, yet you don't adapt to the change, it's a simple warcraft mod, you aren't programing a brand new game.

If there ARE codes that long that improve speed (since bigger code = generally slower unless you know what you're doing), it's usually in a section which they comment as DON'T touch or whatever, which means you don't need to read it. You say making "easy to read and EFFICIENT code", so perhaps it's not easy to read (that single part), but the configurable parts if it's a system or spell should be. Otherwise, you don't need to read their code if they create something, right?

And what's an example of your mentioned "declined spells"?

machine code isnt faster than assembly... since assembly basically IS machine code...

Well, I think that with speed... comes great responsibility...no I'm kidding, I think that with speed comes simplicity. So when you want to make an efficient code, you would probably also want to make it as simple as possible, so it's easier to read.

I guess simplicity and efficiency are, if not similar, then pretty dependent (in this case).

That's because wc3c requires very high standards on submitted resources. If they know a better way of coding stuff and you code it poorly, they expect you to fix that. But I admit that I'm not good at perfecting stuff...


Also many of the users still have ancient machines which doesn't give much room for laggs and inefficient codes.

submitted resources must be fast so people dont get bad laggy experience when using it. like who want a nice looking code for physic or spell system when u cant even shoot more than 3-5 instances at the same time... u should know today people want wat works good first and then comes wat looks good. Wat looks good are like windows, they try to make an awesome GUI while they eat alot of the resources, ofc this may be great for newbies or unexperienced, but then it is really bad to aim it tat way, people do actually improve in skill, and if we develope software for easy using which become annoying and slow... then overtime people who evolved pass the noob state will move to faster systems

You guys are not getting the point.

Then tell us the point, O Great One.

vJass is "hard" to read for him, stop vJass return gamecache.

I don't think this is true at all. Please cite an example.

They might seem minor to you, but some of the spells I've seem seen submitted lately are horribly coded. They got rejected for reasons that had nothing to do with speed. In fact what's been appreciated is code re-use and avoiding low level code. Problem is when people do low-level code and they do it wrong.

maybe he means me O_o xD (well i am not "the community") i code as i think it will be the best.

and yes my first goal is performance. and i don't care is someone "can" read the code (someone with enough skill ofc can) and in general if code is readable. i simply code from practical beign and not theoretical. (and i never code for someone but just for me.)
so this thread is sensless imo =)

lol does jass have assembly ? what is low level ? xDDDDDD (epic lulz)
well this all code story is pure shit.
1) no one release maps
2) if someone release maps they are crap
3) who care ? gamers don't =)
4) you simply don't get FOR WHAT this all is made. it's made to make maps (and make the process easier). (and we return to the 1 point)

and the last point is.
it doesn't matter HOW the map is written if it works well. (and is interesting and fun)

the last example of "standartization" and awesome systems i saw in a Vestras map. and he complained what he have performance issues... pfff it's just lol nothing more. ofc you will if you put in the map a whole bunch of shit systems... (useless systems) "but they are so cool !" but anyway useless... and the most important thing they are not adapted to the map. so in end case you will need to rewrite some ot them (and first you need to understand how they do work etc.)

it's all games... like launching Win games on Linux =) (and be fucking proud of it)

Enough skill at disphering gibberish. Try indenting and giving variables proper names, that doesn't actually slow down your code at all. Well the fact that we can barely read your posts probably has a lot to do with barely being able to read your code.

Low level is basically redoing stuff that you can outsource to a perfectly good existing library. You hide the low level code from your system/spell and save a ton of work and make it more readable. Of course there aren't good libraries for everything yet.

Vestras' map really isn't a shining example of using systems correctly, he had way too many, and a lot of them were outdated.

The job of a good system is to be general enough that it will work for anybody's map while still giving you all the higher level functionality you might want. That's a tough goal to achieve.

Anyway, I will agree that what matters in the end is the game and whether it's fun. It is pointless to make systems all day when very few people wind up releasing a map that uses all that fancy stuff.

All of the systems I make are in the end for my personal use. But I've found that generalizing and modularizing all of my stuff, while improving it thanks to all the feedback I get from other people using it, winds up improving the quality of the final result a lot. And in few months maybe someone will make stuff using my own systems that I wind up using myself.

bullshit.

A good system will not need any extra adaptation, or it will let you adapt it to the map through its configuration without much effort.

Of course players don't care how something is written, they do care about not having updates for a map fast, or about having retarded lag or bugs caused by doing stupid things. And of course, they do care about you ever releasing the map. And being rather fast with updating it. If a map is a full of disorganized garbage code without any planning and the so-called mapper is such a programmer guru that he can't accept other people's code into his maps. He will take 3x the time to release it and he might never really fix any bugs found after the release. Of course, his e-peen will feel so large after he noticed how you need to be have leet skills to actually decrypt any code on it and update it or abotu how it has 1 extra fps... I guess that's great...

Regarding your little anecdotal example, I could bring thousands of examples from the opposite side as well. Why is it most maps don't ever get finished or even released? Is it because the map maker didn't accomplish enough speed? Or could it be because most people follow some broken, disorganized coding pattern? Or perhaps it is because of people loving to waste years inventing wheels that have already been invented?

Of course implementing a system needs you to know about it so you can understand what it does. Using other people's code in your map requires a level of expertize much higher than coding as you go and improvising. It also requires good organization and understanding of the people's code. Also being able to pick correctly what you are looking for. It is true that for some inferior minds out there it is much easier to just produce random code as they go without doing organization.

Of course, a mouse just wandering around randomly will eventually solve a maze, and in fact, he could solve the maze very quickly due to dumb luck. But if the mouse could smell the cheese, have a map and listend to directions of other mice, he could probably get in there much sooner, and when he gets in there he would be sure it was cheeses what he found.


that's way too easy to be proud of it.




low level vs. high level, very few people actually understand that there are not just two levels. There are plenty of layers everywhere. This is probably due to the fact the programmers learned thousands of lessons ever since the 1970 they came up with ideas related to layers, modularity, code reuse and some other crazy stuff. I wonder what made them move to them from the old times were every code you made was specifically for an specific computer on a specific company and they spent ages focusing on how to make the programs faster... Why did they move from it, probably a mystery...

You are messing with my staff, you are free to come and bring some non-sense accusation, but since you did, I am asking you for an actual example, if you don't bring one you might die.

I don't remember the last time I graveyarded something for not being fast enough, unless of course it is something ridiculous such as doing O(n) stuff when O(1) is completely possible and n is in no way guaranteed to remain slow.

Extreme speed issues need fixing, this is the reason everyone ditched handle vars, when it reaches a point players notice the problem it is not good.

Edit: Bleh, I looked at your RPG monster respawn system and if this thread is about that, I'll get really angry. It deserved graveyarding, if you actually used PUI or AutoIndex or UnitIndexingUtils so that it didn't monopolize theUserData and you also had good documentation it could have a chance, but in its current state... If you do those changes you are free to try again.

I see where he's coming from and in some cases I suppose its true (not in the extreme way he means it, but...). There have been times where someone said that code could be changed to make a completely unnoticeable change in speed... Like 1fps, as Vex said. But they're usually minor changes... If a major change is required, it's probably for a good reason.

I mean for example, I doubt I'd see any sort of performance change between using GroupUtils and doing it the old fashioned way, so going nuts over someone for not using GroupUtils (not that I've seen that happen, but for the sake of example) is a bit silly. I understand the mentality; Why reinvent the wheel? But with the exception of situations that require nano-second precision (ala Physics systems), obsession over performance can seem a bit over-the-top to some.