A major objective of software development is to focus on delivery of features implemented in good quality code.
Knowledgeable developers are supposed to write software with good performance to the extent of their understanding (that is, in the software module they are working on). For example, they should be able to use appropriate algorithms and data structures when implementing various parts of the system. In other words, the first implementation which they wrote to satisfy a unit test would have the good performance characteristic that the final product is supposed to have.
However, when the system is large and complex, consisting of many components written by different people/teams and include multiple vendors, is it more productive for a company to separate the roles of performance engineering from software developers, so that software developers can focus on features and correctness that meet specification, and the performance engineer can focus on measuring and improving performance without affecting feature and correctness?
Put simply, are there two different hats, requiring two different mind-sets?
From the answers I got from another question An alternative to requiring red in TDD: reverting code change?, it dawns on me that during the main software development time, meeting functional requirements is a must-have while software performance is a nice-to-have.
- Tests on functional requirements have deterministic outcomes, usually Pass/Fail, or Accept/Reject.
- Performance characteristics don't have a fixed Accept/Reject target, but do have a metric which can drive the performance-optimizing effort.
- Future changes in functional requirements may make it necessary to sacrifice/adjust certain performance objectives.
- Personally, I do agree that there should be a quick feedback cycle between feature implementation and software performance monitoring.
- In this question I'm arguing whether these two are separate specializations - although some people might be specialized in both.
When feature implementation and optimization are done by different developers:
- They will go into conflicts and nothing gets done. (contributed by @quant_dev)
- The resulting software has better performance.
- The resulting software has poor performance.
- (Will ask in a separate question soon.) Is it possible that software performance issues can arise from large software systems that cannot be forecast even by the very knowledgeable software developers? Will a dedicated performance engineer be able to solve it?