which is better, less coding lines or more lines of code ?

Hi,

Performance :
Its not depends on lines of code, but it depends on use of variables and their lifetime scope, if you split your batch process in different function then it will boost your performance.

Approach would be different for Web and desktop application.

Performance is depends on requirement and environment in the time of designing if you could not find proper technology to target environment then it would be a total mess, now you need to understand and prioritize your process to get better performance.

What you can do ?
1. Parallel Processing
2. Caching
etc...

Here is good link which will provide you a good idea about application performance boosting : http://msdn.microsoft.com/en-in/library/ff647813.aspx[^]

Better utilize your resource will give best performance.

As far as my knowledge is concern, performance is not depends on number of coding lines but how you performing operation and number of resources you are using during your application lifetime and releasing them when they are not in use.

Second thing i want to tell you that performance increase can be done through analysis of application through performance measurement tools available and then make appropriate changes to your application code to meet the requirement.

If you follow above factor then it will automatically minmize the line of code so you can say that better code will have no dependency on line of code but it totally depends on how you are carried out your operation with best usages of technology.

At first sight there is no dependency between lines of code and the performance of that code. Just look at these two statements:

a = b + c;

a
=
b
+
c
;

The first one takes one line, the second one six lines. Nevertheless, they will end up generating exactly the same code.

However, leaving such unusual cases out of consideration, there are some relations between lines of code and the run-time efficiency of that code.

(a) Optimizing a give piece of code ofter leads to more code lines.

One of the optimization techniques is loop unrolling. This often helps to optimize code with an inner loop of a fixed number of iterations. By writing manually down a number of iterations, the loop overhead is reduced and the compiler is given more opportunities to juggle with temporary variables and registers. This clearly leads to more lines of code. Other optimization techniques also have a tendency to lead to more lines of source code.

(b) Refactoring "clumsy" code often leads to better performance and less lines of code.

In all practical cases I have seen, re-implementing a badly written piece of code in a clearer way leads to a reduction of code lines and sometimes better performance. Hence, the rule: "Optimization leads to more code lines", cannot always be applied.

So, there is no general dependency between number of code lines and performance. BUT, it can be said: Doing performance optimization on a well written piece of code often leads to more code lines.

From a Java developers point of view:

- use TDD (test driven development)
- use J2EE strictly! (which leads to much more lines of code!)
- write test as you code (not later - that would be never!)