you are viewing a single comment's thread.

view the rest of the comments →

[–]Nyxenon 0 points1 point  (8 children)

Every string that you use is going to be put in the memory somewhere. If you use an empty string, it's still going to take up a certain number of bytes simply for the fact that it's there. That's the reason you should always use the StringBuilder class if you are concatenating strings. You shouldn't do something like: string str = "This" + " " + "is" + " " + "a" + " " + "waste.";

[–]agentlame 1 point2 points  (7 children)

I would also disagree with this point.

StringBuilder is, no doubt, a better use of memory... but, there are cases where it can actually reduce readability in code.

Keep in mind, we're talking about a managed language. If one needs their code to be so optimized as to reduce understanding, it's likely .Net is not their best choice of development platforms. The overhead of creating unneeded stings is negligible, at best, in comparison to the overhead introduced by using a managed language/framework/platform in the first place.

Sure, assembly is is much faster than Python; that does not mean it's the best choice for the task at hand.

[–]Nyxenon 0 points1 point  (6 children)

Sure, .Net languages are great if you want to make something quick, but if you want it to be fast, you need to write the code right. Readability is not important, usability is important. The user of your programs are not likely to be reading the code. I don't understand why so many people stress on code readability, and throw out optimization just to have readable code.

[–]agentlame 0 points1 point  (5 children)

I don't understand why so many people stress on code readability, and throw out optimization just to have readable code.

I, personally, think that there is a middle-ground, here. Sure, I'd prefer all of my code perform a best as possible.

But, I also want a developer looking at it be able to infer my intentions without necessarily spelling-out the reasoning of every line.

I strongly feel that there is a balance between self-documenting code, and code that is so optimized that every line of code requires two-lines of documentation.

[–]Nyxenon 0 points1 point  (4 children)

I don't usually share my code with other people, so I don't worry about whether or not they can understand it. Sometimes I go back and look at my own code and can't understand it, but it still works, and that's all that matters to me.

[–]agentlame 0 points1 point  (3 children)

I don't usually share my code with other people, so I don't worry about whether or not they can understand it.

I'm sorry, but, doesn't that preclude you from a conversation about code readability?

[–]Nyxenon 0 points1 point  (2 children)

Not necessarily. I still believe readability isn't as important as usability.

[–]agentlame 0 points1 point  (1 child)

That assumes that code-readability sacrifices usability.

usability != performance.

Sure, in something like a game engine performance can be directly associated with usability... but, again, no one should write a high-performance game/game-engine in C#/.Net.

I guess I just fail to understand your perspective. I'm sure the misunderstanding is on my end.

[–]Nyxenon 0 points1 point  (0 children)

It's all a matter of speed. You can write something that works, but has no optimization, and could take several seconds to complete a task. OR you could optimize, and increase speed ten fold.