Imagine I have to work in an unfamiliar and tough passage of code.
Unprofitable Code
I spend time and effort to puzzle it out, and all I get from it is that now I understand that tough passage.
If it was written in the most primitive way possible, using no interesting language or library features (which might have made it less puzzling) then it is unprofitable. I have invested my time in "playing computer," simulating every line of code and tracking each value in my head, or perhaps I walked through every line and watched every variable in a debugger.
I have expended this effort of will and focus but received little in return. I know what this bit of code is doing (for now) but I won't be any faster to write or read other code because of it.
That knowledge will be lost in months, possibly weeks or days.
The unprofitable code, left in its original form, will require as much effort next year as it did this time. It is a productivity speed bump.
Profitable Code
OTOH, if I dig into some unfamiliar and tough passage and learn some idioms, standard library functions, built-in syntax, or framework capabilities then I have been rewarded for my pains.
This is profitable work; I know how to read and write similar code more fluently. It may save me minutes, hours, or even days of work. My investment will pay dividends for a long time.
People familiar with the idioms and method will move quickly through this code, and others will only have to suffer that initial shock of newness once.
The Scouting Rule
I like the "leave it better than you found it" rule.
I could rewrite the unprofitable code as profitable code if I have the time and there are enough tests to make refactoring or rewriting safe.
Without the safety of tests, I wouldn't want to take the chance of breaking all the code that depends on this passage.
If I can't make it profitable, I can make the code less unprofitable.
- I could add tests so that the next person to encounter this code has more safety than I had.
- I could do safe refactorings (rename variables, extract expressions, extract methods) to make it less puzzling.
- If all else fails, I can add some comments.
Is This The Right Thing To Do?
That's all probably obvious and straightforward, but there is a more interesting question underlying all of this:
Does the team want to learn the language and libraries fluently, or are they striving to avoid learning how to use those?
Readability is present in the relationship between a code artifact and its audience; its ENTIRE audience.
I am an author or an editor, but that makes me a minority part of the audience of this source code. All my colleagues and future colleagues who share the codebase are also the audience.
If the last thing they want is to profit from this example then fluent use of the stack is a failing.
If becoming more competent is a goal, then avoiding fluent use is failing.
The important thing is not my writing, but their reading.
And so.... what?
Since readability is a quality of a relationship between the artifact and its audience, I have some choices.
We can change the artifact to meet the audience's requirements and make the code more readable without changing or improving the audience.
We can change the knowledge and comfort of the audience and thereby raise the readability of the code without changing the code in any way.
There is also a middle path: we can change the code and the audience's expectations. It does not have to be all one thing or all the other.
What is your strategy for code readability and developer competence?
This comment has been removed by the author.
ReplyDeleteThis article thoughtfully distinguishes between profitable and unprofitable struggles in coding, emphasizing the importance of learning and improving fluency with language and libraries. It advocates for a balanced approach to code readability—enhancing both the code and the developer's competence for long-term productivity.
ReplyDeleteAre you looking to enhance your cybersecurity skills? Check out the Ethical Hacking Training in Bangalore offered by Indian Cyber Security Solutions.