The core type of work required of developers--writing code--has not changed in decades. But the specific skillsets that the typical developer needs have. When mapping out a development career plan it is important to consider that, not only have newer programming languages become popular, but entire categories of skills that developers were once expected to possess have become irrelevant--at least in some cases.
With these changes in mind, let's take a look at some types of skills that were once critical to be a successful developer but are no longer as technology and the business driving it evolve.
1. Working with compilers
Understanding how compilers work, how to compile code for different operating systems and--most importantly of all--how to combat the various bugs that inevitably arise within compilers were all critical skills for developers. (Perhaps the most famous examples of developers fighting with buggy compilers were the profanity-laced comments left by Microsoft developers in the Windows source code that leaked in the early 2000s.)
Today, however, learning the ins and outs of the compilers associated with whichever language you code in is increasingly less important. Some popular languages, like Python, don't require code to be compiled at all in the traditional sense. And in cases where compiling is required, the process is now typically highly automated using build tools; developers no longer have to compile their code by hand in the way they once did.
On top of all of this, popular compilers are, by and large, simply less buggy than they once were. Languages like Java, C and C++ have been around for decades, and the compilers that most teams use for them have had many of their kinks ironed out by this point.
To be sure, dealing with compilers is still important for some developers in some cases. But it's no longer a top priority for the typical developer.
2. Setting up local development environments
Once upon a time, being a coder meant setting up and maintaining a "development box"--meaning a PC or laptop with all of the tools you needed to write code, as well as to test it. Sometimes you maintained multiple environments on the same computer (typically with the help of virtual machines) so that you could test your code under different conditions.
Today, as software development operations increasingly move the cloud, local development boxes are becoming less important. While some developers may still write code locally, many now simply check code into cloud-based CI/CD pipelines to be tested and built. And, in some cases, even the code itself is written in the cloud using cloud IDEs.
Setting up a development and testing environment may still be important. But doing it locally is no longer as common. Now, you need to know how to work with cloud-based development tools, which are a different sort of beast.
3. Building hardware-dependent features
In our current age of SaaS, many applications are designed to be as hardware-agnostic as possible. They don't interact at a low level with the various hardware components in a users' computer. Instead, they are delivered over the Internet, often in a Web browser.
To be sure, there are exceptions. If you are a game developer, or you write code that does GPU offloading, for example, writing applications that interface directly with hardware still matters. But most other developers no longer have to think much about the specific hardware inside their end users' computers. They just write code that can be deployed on a server and interface with users over the network.
4. Knowing the nuances of operating systems
There was a time when being a good developer meant that you knew how a win32 kernel was different from win64, or which libraries were installed by default on a Red Hat Enterprise Linux server as compared to, say, an Ubuntu one. Understanding these nuances mattered to ensure that the code you wrote would work equally well on different types and flavors of operating systems.
New types of deployment technologies have made this type of operating system-specific knowledge less important. If you deploy an application inside a container, for example, it will be abstracted away from the host server in many respects, and will typically work the same regardless of which Linux distribution is hosting it. At the same time, the pace of evolution of Windows has slowed down over the past decade, reducing the number of different Windows flavors that developers might have to cater to. Plus, in the age of SaaS, local end user environment configurations matter less and less overall.
Operating system differences certainly still matter in some cases. But, depending on the type of application you are writing, they may not matter for your work. That is a big change from the past.
5. Software packaging
Just as new deployment technologies have made applications more OS-agnostic, they have also reduced the importance of learning different methods for packaging applications.
Today, preparing an application for deployment is often as simple as wrapping some files inside a Docker image, uploading it to a container registry and calling it a day. Or perhaps you just bake the application into a virtual machine image and give that to your users to deploy in the cloud. In many cases, you no longer have to worry about building multiple .deb or .rpm files on Linux (and making sure to configure the various branches of your dependency trees correctly), or .exe files on Windows.
Sure, packaging is still important for many developers. But for many, there are fewer types of packages to have to think about. In addition, building the packages that we use today, like Docker images, is arguably simpler.
If you learned to code 10 or 20 years ago--or, in some cases, even in just the past several years, before the container and cloud revolutions had fully taken off--the skills and strategies you learned may now no longer apply as you evolve your development career plan. So, before investing your time in learning to master a specific skill, step back and ask yourself if it's really an area of expertise that is in demand among the modern generation of developers.