So looking around earlier I noticed some comments about long methods being bad practice.
I am not sure I always agree that long methods are bad (and would like opinions from others).
For example I have some Django views that do a bit of processing of the objects before sending them to the view, a long method being 350 lines of code. I have my code written so that it deals with the parameters - sorting / filtering the queryset, then bit by bit does some processing on the objects my query has returned.
So the processing is mainly conditional aggregation, that has complex enough rules it can't easily be done in the database, so I have some variables declared outside the main loop then get altered during the loop.
variable_1 = 0 variable_2 = 0 for object in queryset : if object.condition_condition_a and variable_2 > 0 : variable 1+= 1 ..... ... . more conditions to alter the variables return queryset, and context
So according to the theory I should factor out all the code into smaller methods, so That I have the view method as being maximum one page long.
However having worked on various code bases in the past, I sometimes find it makes the code less readable, when you need to constantly jump from one method to the next figuring out all the parts of it, while keeping the outermost method in your head.
I find that having a long method that is well formatted, you can see the logic more easily, as it isn't getting hidden away in inner methods.
I could factor out the code into smaller methods, but often there is is an inner loop being used for two or three things, so it would result in more complex code, or methods that don't do one thing but two or three (alternatively I could repeat inner loops for each task, but then there will be a performance hit).
So is there a case that long methods are not always bad? Is there always a case for writing methods, when they will only be used in one place?
UPDATE: Looks like I asked this question a over a year ago.
So I refactored the code after the (mixed) response here, split it into methods. It is a Django app retrieving complex sets of related objects from the database, so the testing argument is out (it would have probably taken most of the year to create relevant objects for the test cases . I have a "this needs done yesterday" type work environment before anyone complains). Fixing bugs in that part of the code is marginally easier now, but not massively so.
#comment 1 bit of (uncomplicated) code 1a bit of code 2a #comment 2 bit of code 2a bit of code 2b bit of code 2c #comment 3 bit of code 3
method_call_1 method_call_2 method_call_3 def method_1 bit of (uncomplicated) code 1a bit of code 2a def method_2 bit of code 2a bit of code 2b bit of code 2c def method_3 bit of code 3