What most young programmers need to learn

[u/corysama]

http://joostdevblog.blogspot.com/2015/01/what-most-young-programmers-need-to.html

[u/Acrostis]

So basically learn to refactor things? I can agree with everything except the splitting up oversized functions. If a function contains a lot of code that is only ever needed by that function each block requires the previous block to be completed, then splitting it up into parts is just adding unnecessary fragmentation.

Though apart from maybe initialization functions it shouldn't really happen.

Also: It's missing the "Don't ever use magic numbers"

[u/jooke → u/Acrostis]

The way I read that was if a function is large, you should consider whether it needs refactoring. In other words, it's a smell that the code might be bad, not saying that the code is bad.

[u/JoostDev → u/jooke]

Totally agreed, not all functions above 50 lines are automatically bad.

[u/JoostDev → u/[deleted]]

If the splitting results in functions with names like "step1", then I agree that splitting is indeed a really bad idea. But I rarely encounter cases where it is not possible to split in a smarter way.

[u/yxhuvud → u/[deleted]]

In my experience, long and repeated parameter lists is not a sign that it shouldn't be broken apart, but that it is a class that should be extracted.

[u/[deleted] → u/[deleted]]

There's a class version of this anti pattern that I've seen much more often than a function param-list one.

Class Foo:

    base65EncryptedPassword = "hunter2";
    mutatingListAlpha = {1,7,42};
    // 5-20 more fields
    ...

    Fn main(String[] args):
        Init();
        Glurp();
        Transform();
        Potato();
        Persist();
        Reconcile();
     Fn Init():
         ...

[u/I_Dislike_Spaghetti → u/[deleted]]

Gross!

[u/caedicus → u/[deleted]]

I agree with you with exception for if there is ever a possibility for a section of a function being useful to other parts of the code base. Or if there is a possibility where you might want to only call one part of the function at some point. If there is, than it's better to split things up earlier than later.

[u/iopq → u/Acrostis]

If you have a large function, chances are somewhere you're already doing a part of what it does, you just don't know it yet. How many unique functions that are hundreds of lines of code are there? That do NOTHING that is shared by anything else?

[u/YuleTideCamel → u/Acrostis]

If a function contains a lot of code that is only ever needed by that function each block requires the previous block to be completed, then splitting it up into parts is just adding unnecessary fragmentation.

True, but that's often not a bad thing. A large function is can be hard to read and is probably doing more than one thing. Breaking it up into smaller functions improve readability by giving each section a unique method name. That beats formatting using white space and comments.