Recently, I have been noticed numerous of blogs, articles and other sources reminding me of the technologies, techniques and practices that the software development industry has begun to discard and developers are or should be ignoring. While many of these are obvious obsolete technologies that have been replaced by others across all modern and common platforms; there are many that are still necessary in today’s software development environments and organizations.
The techniques to which I am referring are low level coding skills, memory management, code optimization and performance optimizations. I know that every application does not require the “optimized” and “superlative” implementation and performance, but many environments still do require better performance and resource management than our tools can provide. To ignore and discard these techniques as un-necessary and obsolete would be similar to saying that we don’t need to learn to add, subtract or divide since we all have cell phones and computers which always have a calculator application.
What concerns me most about this trend is that it targets several of the most complex, intricate and challenging areas of expertise that are still completely necessary in many of our more limited environments. And even in our more contemporary platforms, these areas are no where near maturity. I know we are advancing technology at a fast pace and will outgrow some of these issues, but I am tired of waiting (possibly un-necessarily) when I run multiple applications at the same time on my portable devices. And I know as an engineer, even the best of these platform based solutions are not nearly as efficient as what a highly skilled engineer can do.
Yes, most applications to have very acceptable performance do not have to be optimized and there will always be those one-off or quick and dirty implementations due to other time or business constraints. BUT, we need to consider that we have not reached the “nirvana” that many platform developers, tool developers and academics would like us to believe. When the complex code we rely on is so bloated, inefficient and hidden behind the scenes; how do we debug, accurately test and correct any issues without understanding the techniques used. If these techniques are further blurred by poor implementations, excessive code and disproportionate resource requirements then; the performance and quality of our applications will suffer. Especially, when we are running multitudes of these applications on server implementations in virtual environments all on the same hardware platform; while it may not be the perfect storm, it sure sounds like a hurricane to me.
So, before we ignore these highly valuable skills and techniques because they are not so pleasant to many of us and very difficult to most; I think we should remember that there is still a great demand and need for engineers capable of developing, debugging and appreciation of low level, embedded and complex technology skills.
The trick is to not only have the expertise but also the wisdom and sense to determine when and where they need to be applied. Yes, we may need fewer people with these proficiencies but like many skills, historically, the rarer the “required” skill set is the more valuable the resource is…
Ahh, got a bug… it sounds like a job for “super geek” and he is not cheap!